Files
MikrotikManager/backend/src/modules/mcp/operation-execution-origin.ts
T
Denozordec 79ab7b45aa
Docker images / prepare-release (push) Successful in 14s
Docker images / backend-test (push) Failing after 3m16s
Docker images / backend-image (push) Skipped
Docker images / frontend-image (push) Successful in 2m47s
Docker images / updater-image (push) Successful in 39s
Docker images / netflow-agent-image (push) Successful in 32s
Docker images / publish-release (push) Skipped
Docker images / notify-webhook (push) Skipped
feat(mcp): разрешить автономное выполнение планов сервисным ключом
2026-11-22 12:59:36 +07:00

318 lines
29 KiB
TypeScript

/** Ordinary runner root BEFORE operation/app/server configuration locks. This
* is provenance, never a global-writer permit or a public callback/JSON API. */
import { AsyncLocalStorage } from "node:async_hooks"
import { createHash, randomUUID } from "node:crypto"
import { readFile } from "node:fs/promises"
import { readFileSync } from "node:fs"
import { join } from "node:path"
import { performance } from "node:perf_hooks"
import type { QueryConfig, PoolClient } from "pg"
import { mcpTemporaryGrantSchema, type McpObjectRef } from "@mmapp/contracts/mcp"
import { pool } from "../../db/index.js"
import { sharedDatabaseGate } from "../../services/shared-database-gate.js"
import { assertNoConfigurationLockContext } from "../../services/config-mutation-lock.js"
import { assertNoOperationConfigurationLockContext } from "../../services/operation-config-lock-lease.js"
import { validatePrincipal, audit, type McpPrincipal, type StoredOperation } from "./store.js"
import { decryptSecret, fingerprint, McpError, mcpStateDirectory, privateFingerprinterExisting } from "./security.js"
import { findActionByOperation } from "./actions.js"
import { evaluateMcpPolicy, hasUnattendedPlanAuthority, operationApprovalRequirement } from "./policy.js"
import { changeMutationCost } from "./change-cost.js"
import { assertOriginalMcpTemporaryGrant, type OriginalServiceGrant } from "./temporary-grant-origin.js"
import type { ChangeEvidence } from "./action-types.js"
export const MCP_OPERATION_PRIVATE_CLAIM_KEY = "__mmappMcpOperationClaimV1"
export interface McpOperationExecutionMetadata {
readonly operationId: string; readonly planId: string; readonly connectionId: string; readonly ownerId: string
readonly operationName: string; readonly operationVersion: number; readonly policyVersion: number; readonly generation: string
readonly phase: "forward"; readonly approved: boolean; readonly approvalSource?: "connection-policy"; readonly principal: Readonly<McpPrincipal>
readonly sealedEvidenceProof: string; readonly sealedPayloadProof: string
readonly originalTemporaryGrantProof: string; readonly originalTemporaryGrantExpiresAt: number | null; readonly originalExpiresAt: number
readonly serverIds: readonly number[]; readonly resources: readonly McpObjectRef[]
readonly privateInput: Readonly<Record<string, unknown>>; readonly evidence: Readonly<ChangeEvidence>
}
declare const operationOriginBrand: unique symbol
export type McpOperationExecutionOrigin = Readonly<{ [operationOriginBrand]: true }>
type Entry = { active: boolean; nonce: string; metadata: Readonly<McpOperationExecutionMetadata>; grant: Readonly<OriginalServiceGrant>
end: number; controller: AbortController; timer?: ReturnType<typeof setTimeout>; directory: string; keyProof: string; keyEpoch: string }
const roots = new AsyncLocalStorage<Entry>(), tokens = new WeakMap<object, Entry>()
declare const admissionStartBrand: unique symbol
declare const admissionBrand: unique symbol
export type McpOperationAdmissionStart = Readonly<{ [admissionStartBrand]: true }>
export type McpOperationAdmission = Readonly<{ [admissionBrand]: true }>
type Admission = { operationId: string; planId: string; connectionId: string; nonce: string; principal: Readonly<McpPrincipal>; grant: Readonly<OriginalServiceGrant>
generation: string; directory: string; keyEpoch: string; operationName: string; operationVersion: number; policyVersion: number; evidenceProof: string; payloadProof: string; approvalSource?: "connection-policy" }
const starts = new WeakMap<object, { principal: Readonly<McpPrincipal>; wall: number; mono: number; directory: string; generation: string; keyEpoch: string }>(), admissions = new WeakMap<object, Admission>()
const deny = (): never => { throw new McpError("PERMISSION_DENIED", "Исходный MCP operation root недоступен", 403) }
const purpose = "mcp-operation-execution-origin-v1", keyMessage = "mcp-operation-execution-origin-key-epoch-v1"
const sha = (value: string) => createHash("sha256").update(value).digest("hex")
function existingMaterial(directory: string) {
if (mcpStateDirectory() !== directory) return deny()
const generation = readFileSync(join(directory, "access-generation")), key = readFileSync(join(directory, "encryption-key"))
try {
if (generation.length !== 32 || key.length !== 32 || mcpStateDirectory() !== directory) return deny()
return { generation: generation.toString("hex"), keyEpoch: createHash("sha256").update(key).digest("hex") }
} finally { key.fill(0) }
}
function frozen<T>(value: T): T { if (value && typeof value === "object") { Object.values(value).forEach(frozen); Object.freeze(value) }; return value }
export function stripMcpOperationExecutionPrivateResult(value: unknown): unknown {
if (!value || typeof value !== "object" || Array.isArray(value)) return value
return Object.fromEntries(Object.entries(value).filter(([key]) => key !== MCP_OPERATION_PRIVATE_CLAIM_KEY))
}
const SOURCE_SQL = `/* mcp-operation-root:source */ SELECT o.id,o.plan_id,o.connection_id,o.state AS operation_state,
o.result->>'__mmappMcpOperationClaimV1' AS claim_nonce,p.operation_id,p.operation_version,p.policy_version,p.generation,
p.state AS plan_state,p.expires_at,p.approved_by,
CASE WHEN octet_length(p.payload::text)+octet_length(p.evidence::text)<=8388608 THEN p.payload END AS payload,
CASE WHEN octet_length(p.payload::text)+octet_length(p.evidence::text)<=8388608 THEN p.evidence END AS evidence,
c.owner_id,c.owner_permissions,c.policy,c.owner_valid_until,c.generation AS connection_generation,
coalesce((SELECT jsonb_agg(g) FROM (SELECT id::text,CASE WHEN octet_length(payload::text)<=1048576 THEN payload END AS payload FROM public.mcp_grants WHERE connection_id=o.connection_id
AND revoked_at IS NULL AND payload->>'credentialId'=$3 LIMIT 2)g),'[]'::jsonb) AS grants,
(WITH limited AS MATERIALIZED (SELECT object_ref FROM public.mcp_protections LIMIT 1001),
budget AS (SELECT coalesce(sum(octet_length(object_ref::text)),0) AS bytes FROM limited)
SELECT CASE WHEN bytes<=1048576 THEN (SELECT coalesce(jsonb_agg(object_ref),'[]'::jsonb) FROM limited) END FROM budget) AS protections,
(SELECT count(*)::int FROM public.mcp_read_leases WHERE connection_id=o.connection_id AND expires_at>now()) AS concurrent_reads
FROM public.mcp_operations o JOIN public.mcp_plans p ON p.id=o.plan_id AND p.connection_id=o.connection_id
JOIN public.mcp_connections c ON c.id=o.connection_id WHERE o.id=$1 AND o.connection_id=$2 LIMIT 2`
const CLAIM_SQL = `/* mcp-operation-root:claim */ UPDATE public.mcp_operations o SET state='running',
result=coalesce(o.result,'{}'::jsonb)||jsonb_build_object('__mmappMcpOperationClaimV1',$4::text)
FROM public.mcp_plans p WHERE o.id=$1 AND o.plan_id=$2 AND o.connection_id=$3 AND o.state='pending'
AND (o.result IS NULL OR jsonb_typeof(o.result)='object' AND NOT o.result ? '__mmappMcpOperationClaimV1')
AND p.id=o.plan_id AND p.connection_id=o.connection_id AND p.state='executing' AND p.operation_version=$5 AND p.policy_version=$6
AND p.generation=$7 AND p.expires_at>now() AND encode(sha256(convert_to(p.evidence->>'sealed','UTF8')),'hex')=$8
AND encode(sha256(convert_to(p.payload->>'sealed','UTF8')),'hex')=$9 RETURNING o.id,o.plan_id,o.connection_id,o.state,o.result`
function life(entry: Entry) { if (entry.controller.signal.aborted || Date.now() >= entry.metadata.originalExpiresAt || performance.now() >= entry.end) deny() }
function owned(entry: Entry) { if (!entry.active || roots.getStore() !== entry) deny(); life(entry) }
async function files(entry: Entry) {
life(entry); if (mcpStateDirectory() !== entry.directory) deny()
const bytes = await readFile(join(entry.directory, "access-generation")); life(entry)
if (bytes.length !== 32 || bytes.toString("hex") !== entry.metadata.generation || mcpStateDirectory() !== entry.directory) deny()
if ((await privateFingerprinterExisting(purpose))(keyMessage) !== entry.keyProof || mcpStateDirectory() !== entry.directory) deny(); life(entry)
}
async function sql(text: string, values: unknown[], deadlineAt: number) {
if (Date.now() >= deadlineAt) return deny()
const config: QueryConfig & { query_timeout: number } = { text, values, query_timeout: Math.max(1, Math.min(5000, deadlineAt - Date.now())) }
return pool.query(config)
}
async function rowFor(operationId: string, principal: McpPrincipal, deadlineAt: number) {
const result = await sql(SOURCE_SQL, [operationId, principal.connectionId, principal.credentialId], deadlineAt)
if (result.command !== "SELECT" || result.rowCount !== 1 || result.rows.length !== 1) return deny()
return result.rows[0]
}
/** Timing anchor only, not authority. The fixed INSERT below is the only minter. */
export function beginMcpOperationAdmission(principal: McpPrincipal): McpOperationAdmissionStart {
const wall = Date.now(), mono = performance.now(), directory = mcpStateDirectory(), material = existingMaterial(directory)
const token = Object.freeze(Object.create(null)) as McpOperationAdmissionStart
starts.set(token, { principal: frozen(structuredClone(principal)), wall, mono, directory, ...material }); return token
}
/** Trusted creating-transaction seam. This method owns the fresh INSERT and its
* real receipt; it cannot mint from an existing pending row or a later UPDATE.
* xmin is an additional same-transaction pin, not protection from a DB owner. */
export async function insertMcpOperationAdmission(client: PoolClient, start: McpOperationAdmissionStart, planId: string, idempotencyKey: string,
original: OriginalServiceGrant): Promise<{ operation: StoredOperation; admission: McpOperationAdmission; originalGrant: Readonly<OriginalServiceGrant> }> {
const anchor = starts.get(start); starts.delete(start)
if (!anchor || !original || original.admissionExpiresAt <= Date.now()) return deny()
const material = existingMaterial(anchor.directory)
if (material.generation !== anchor.generation || material.keyEpoch !== anchor.keyEpoch) return deny()
const transaction = await client.query("SELECT pg_current_xact_id_if_assigned()::text AS creating_xid")
if (transaction.command !== "SELECT" || transaction.rowCount !== 1 || typeof transaction.rows[0]?.creating_xid !== "string") return deny()
const beforePrincipal = existingMaterial(anchor.directory)
if (beforePrincipal.generation !== anchor.generation || beforePrincipal.keyEpoch !== anchor.keyEpoch) return deny()
const principal = anchor.principal, current = await validatePrincipal(principal, client)
await assertOriginalMcpTemporaryGrant(client, principal.connectionId, principal.credentialId, original)
const beforeInsert = existingMaterial(anchor.directory)
if (beforeInsert.generation !== anchor.generation || beforeInsert.keyEpoch !== anchor.keyEpoch) return deny()
const id = randomUUID(), inserted = await client.query<StoredOperation>("INSERT INTO mcp_operations(id,plan_id,connection_id,idempotency_key) VALUES($1,$2,$3,$4) RETURNING *", [id, planId, principal.connectionId, idempotencyKey])
if (inserted.command !== "INSERT" || inserted.rowCount !== 1 || inserted.rows.length !== 1 || inserted.rows[0].id !== id || inserted.rows[0].plan_id !== planId
|| inserted.rows[0].connection_id !== principal.connectionId || inserted.rows[0].state !== "pending") return deny()
const pin = await client.query(`SELECT o.id,o.plan_id,o.connection_id,o.xmin::text=mod(pg_current_xact_id()::text::numeric,4294967296)::text AS creating_transaction,
p.operation_id,p.operation_version,p.policy_version,p.generation,
CASE WHEN octet_length(p.payload::text)+octet_length(p.evidence::text)<=8388608 THEN p.evidence END AS evidence,
CASE WHEN octet_length(p.payload::text)+octet_length(p.evidence::text)<=8388608 THEN p.payload END AS payload,p.expires_at
FROM public.mcp_operations o JOIN public.mcp_plans p ON p.id=o.plan_id AND p.connection_id=o.connection_id WHERE o.id=$1`, [id])
if (pin.command !== "SELECT" || pin.rowCount !== 1 || pin.rows.length !== 1) return deny()
const row = pin.rows[0]
if (row.creating_transaction !== true || row.id !== id || row.plan_id !== planId || row.connection_id !== principal.connectionId || row.generation !== current.generation
|| row.generation !== anchor.generation || row.policy_version !== current.policy.version || !(row.expires_at instanceof Date) || typeof row.evidence?.sealed !== "string" || typeof row.payload?.sealed !== "string") return deny()
const finalMaterial = existingMaterial(anchor.directory)
if (finalMaterial.generation !== anchor.generation || finalMaterial.keyEpoch !== anchor.keyEpoch) return deny()
const expiresAt = Math.min(original.admissionExpiresAt, row.expires_at.getTime(), Date.parse(principal.credentialExpiresAt), Date.parse(current.policy.expiresAt), current.owner_valid_until.getTime())
const grant = frozen({ ...original, admissionExpiresAt: expiresAt,
admissionMonotonicEnd: Math.min(original.admissionMonotonicEnd, anchor.mono + Math.max(0, expiresAt - anchor.wall)),
monotonicEnd: original.expiresAt === null ? Infinity : Math.min(original.monotonicEnd, anchor.mono + Math.max(0, original.expiresAt - anchor.wall)) })
if (Date.now() >= expiresAt || performance.now() >= grant.admissionMonotonicEnd) return deny()
const admission = Object.freeze(Object.create(null)) as McpOperationAdmission
admissions.set(admission, { operationId: id, planId, connectionId: principal.connectionId, nonce: randomUUID(), principal, grant,
generation: row.generation, directory: anchor.directory, keyEpoch: anchor.keyEpoch, operationName: row.operation_id, operationVersion: row.operation_version, policyVersion: row.policy_version,
evidenceProof: sha(row.evidence.sealed), payloadProof: sha(row.payload.sealed), approvalSource: row.evidence.approvalSource })
return { operation: inserted.rows[0], admission, originalGrant: grant }
}
function grantFrom(row: Record<string, unknown>, principal: McpPrincipal) {
if (!Array.isArray(row.grants) || row.grants.length > 1) return deny()
if (!row.grants.length) return { proof: fingerprint({ credentialId: principal.credentialId, grant: null }), expiresAt: null, value: undefined }
const entry = row.grants[0]
if (!entry || typeof entry.id !== "string" || !entry.payload || entry.payload.credentialId !== principal.credentialId) return deny()
const { credentialId: _credential, ...raw } = entry.payload, value = mcpTemporaryGrantSchema.parse(raw)
if (Date.parse(value.startsAt) > Date.now() || Date.parse(value.expiresAt) <= Date.now()) return deny()
return { proof: fingerprint({ rowId: entry.id, credentialId: principal.credentialId, grant: value }), expiresAt: Date.parse(value.expiresAt), value }
}
function source(entry: Entry, row: Record<string, unknown>, state: "pending" | "running") {
const m = entry.metadata
if (row.id !== m.operationId || row.plan_id !== m.planId || row.connection_id !== m.connectionId || row.operation_state !== state
|| state === "running" && row.claim_nonce !== entry.nonce || row.plan_state !== "executing" || row.owner_id !== m.ownerId
|| row.operation_id !== m.operationName || row.operation_version !== m.operationVersion || row.policy_version !== m.policyVersion
|| row.generation !== m.generation || row.connection_generation !== m.generation || !!row.approved_by !== m.approved
|| m.approvalSource && row.approved_by !== m.ownerId
|| !(row.expires_at instanceof Date) || row.expires_at.getTime() < m.originalExpiresAt
|| !row.evidence || typeof row.evidence !== "object" || !row.payload || typeof row.payload !== "object") deny()
const evidence = row.evidence as { sealed?: unknown; approvalSource?: unknown }, payload = row.payload as { sealed?: unknown }
if (typeof evidence.sealed !== "string" || typeof payload.sealed !== "string" || evidence.approvalSource !== m.approvalSource || sha(evidence.sealed) !== m.sealedEvidenceProof || sha(payload.sealed) !== m.sealedPayloadProof) deny()
const action = findActionByOperation(m.operationName)
if (action.operation.version !== m.operationVersion) deny()
const grant = grantFrom(row, m.principal)
if (grant.proof !== m.originalTemporaryGrantProof || grant.expiresAt !== m.originalTemporaryGrantExpiresAt || !Array.isArray(row.protections) || row.protections.length > 1000) deny()
const policy = row.policy as Parameters<typeof evaluateMcpPolicy>[0]["policy"]
const protections = row.protections as Parameters<typeof evaluateMcpPolicy>[0]["protections"]
if (policy.version !== m.policyVersion || m.approvalSource && !hasUnattendedPlanAuthority(policy) || !(row.owner_valid_until instanceof Date) || row.owner_valid_until.getTime() < m.originalExpiresAt) deny()
const approval = operationApprovalRequirement(policy, m.operationName, m.evidence.target, m.evidence.requiresHuman)
const decision = evaluateMcpPolicy({ operationId: m.operationName, policy, ownerPermissions: row.owner_permissions as string[], target: m.evidence.target,
objects: [...m.evidence.objects, ...approval.objects],
objectCount: changeMutationCost(m.evidence) + (m.evidence.recovery ? 1 : 0),
protections: [...protections, ...approval.protections],
usage: { callsInMinute: 0, mutationsInHour: 0, concurrentReads: Number(row.concurrent_reads) }, auditAvailable: true, temporaryGrant: grant.value })
if (decision.decision === "denied" || decision.decision === "approval-required" && (!m.approved || m.approvalSource)) deny()
}
/** Two current joined snapshots around real principal/grant checks. Nothing is
* cached across calls; the final SQL validates exact source + policy + grant. */
async function current(entry: Entry, state: "pending" | "running") {
await files(entry)
const initialMaterial = existingMaterial(entry.directory); if (initialMaterial.generation !== entry.metadata.generation || initialMaterial.keyEpoch !== entry.keyEpoch) deny()
const before = await validatePrincipal(entry.metadata.principal); life(entry)
if (before.owner_id !== entry.metadata.ownerId) deny()
source(entry, await rowFor(entry.metadata.operationId, entry.metadata.principal, entry.metadata.originalExpiresAt), state); life(entry)
await assertOriginalMcpTemporaryGrant(pool, entry.metadata.connectionId, entry.metadata.principal.credentialId, entry.grant); life(entry)
await files(entry)
const finalMaterial = existingMaterial(entry.directory); if (finalMaterial.generation !== entry.metadata.generation || finalMaterial.keyEpoch !== entry.keyEpoch) deny()
const after = await validatePrincipal(entry.metadata.principal); life(entry)
if (after.owner_id !== entry.metadata.ownerId) deny()
source(entry, await rowFor(entry.metadata.operationId, entry.metadata.principal, entry.metadata.originalExpiresAt), state); life(entry)
}
/** Private owner nonce prevents an uncertain zero-row claimant from closing a
* different winner. No pending reset, verified ACK fabrication or native retry. */
async function interrupt(entry: Admission) {
const deadline = Date.now() + 2500; let client: PoolClient | undefined, safe = false, retired = false, timeout: ReturnType<typeof setTimeout> | undefined
let stage = "checkout"
const connect = pool.connect().then(value => { if (retired || Date.now() >= deadline) { value.release(true); throw Error("Late cleanup checkout") }; client = value; return value })
const stopped = new Promise<never>((_yes, no) => { timeout = setTimeout(() => { retired = true; client?.release(true); client = undefined; no(Error("Operation root cleanup deadline")) }, 2500) })
const work = async () => {
const owned = await connect
const query = (text: string, values: unknown[] = []) => {
if (retired || Date.now() >= deadline || !sharedDatabaseGate.hasActiveAdmission()) throw Error("Late cleanup SQL")
return owned.query({ text, values, query_timeout: Math.max(1, Math.min(1000, deadline - Date.now())) } as QueryConfig)
}
stage = "begin"
if ((await query("BEGIN")).command !== "BEGIN") throw Error("No cleanup BEGIN ACK")
stage = "operation"
const result = await query(`UPDATE public.mcp_operations SET state='unknown',verification='inconclusive',error_code='PROCESS_INTERRUPTED',
result=jsonb_build_object('needsReview',true,'automaticRetry',false),finished_at=now() WHERE id=$1 AND plan_id=$2 AND connection_id=$3
AND ((state='pending' AND result->>'__mmappMcpOperationClaimV1' IS NULL)
OR (state='running' AND result->>'__mmappMcpOperationClaimV1'=$4)) RETURNING plan_id`, [entry.operationId, entry.planId, entry.connectionId, entry.nonce])
if (result.rows.length) {
stage = "plan"
await query("UPDATE public.mcp_plans SET state='completed' WHERE id=$1 AND connection_id=$2", [entry.planId, entry.connectionId])
stage = "audit"
await audit({ query } as Pick<PoolClient, "query">, "mcp-runner", "operation.interrupted", entry.connectionId,
{ operationId: entry.operationId, planId: entry.planId, origin: "operation-root-v1", retryAllowed: false, sealedEvidenceProof: entry.evidenceProof })
}
stage = "commit"
if ((await query("COMMIT")).command !== "COMMIT") throw Error("No cleanup COMMIT ACK")
safe = true
}
try { await Promise.race([work(), stopped]) } catch (error) {
const sqlState = (error as { code?: unknown } | null)?.code
const category = retired ? "deadline" : error instanceof Error && error.message === "Query read timeout" ? "query-timeout" : "failure"
console.error("MCP operation root cleanup deferred", { operationId: entry.operationId, stage, category, sqlState: typeof sqlState === "string" && /^[0-9A-Z]{5}$/.test(sqlState) ? sqlState : undefined, retryAllowed: false })
}
finally { retired = true; clearTimeout(timeout); if (client) { client.release(!safe); client = undefined } }
}
/** Cleanup SQL owns a live request/exclusive admission. Waiting for repair is
* detached from runner slots; only admission is retried, never native work. */
async function interruptWithinDatabaseAdmission(entry: Admission): Promise<void> {
if (sharedDatabaseGate.hasActiveAdmission()) return sharedDatabaseGate.withinAdmission(() => interrupt(entry))
if (!sharedDatabaseGate.isPaused()) return sharedDatabaseGate.request(() => interrupt(entry))
void (async () => {
while (sharedDatabaseGate.isPaused()) await sharedDatabaseGate.whenOpen()
await sharedDatabaseGate.request(() => interrupt(entry))
})().catch(() => console.error("MCP operation root cleanup deferred", { operationId: entry.operationId, retryAllowed: false }))
}
/** Aborted admission/queue ownership only. A serialized/foreign cap is inert. */
export async function retireMcpOperationAdmission(admission: unknown): Promise<void> {
const entry = admission && typeof admission === "object" ? admissions.get(admission) : undefined
if (!entry) return
admissions.delete(admission as object); await interruptWithinDatabaseAdmission(entry)
}
/** Called exactly by the ordinary runtime before its first pool checkout/lock.
* The callback is fixed runner code; callers supply no metadata/authorizer. */
export async function withMcpOperationExecutionOrigin(admission: unknown, work: () => Promise<void>): Promise<void> {
assertNoOperationConfigurationLockContext(); assertNoConfigurationLockContext()
const admitted = admission && typeof admission === "object" ? admissions.get(admission) : undefined
if (!admitted) return deny()
admissions.delete(admission as object) // One shot even after any failed attempt.
let entry: Entry | undefined, interruptOwn = true
try {
const { operationId, principal, grant: originalGrant } = admitted
if (roots.getStore() || originalGrant.admissionExpiresAt <= Date.now() || originalGrant.admissionMonotonicEnd <= performance.now()) return deny()
const capturedPrincipal = frozen(structuredClone(principal)), directory = admitted.directory, material = existingMaterial(directory)
if (material.generation !== admitted.generation || material.keyEpoch !== admitted.keyEpoch) return deny()
const bytes = await readFile(join(directory, "access-generation")); if (bytes.length !== 32) return deny()
const sign = await privateFingerprinterExisting(purpose), keyProof = sign(keyMessage), generation = bytes.toString("hex")
const beforeAuthorizer = existingMaterial(directory); if (beforeAuthorizer.generation !== admitted.generation || beforeAuthorizer.keyEpoch !== admitted.keyEpoch) return deny()
const connection = await validatePrincipal(capturedPrincipal)
const row = await rowFor(operationId, capturedPrincipal, originalGrant.admissionExpiresAt)
if (row.operation_state !== "pending") { interruptOwn = false; return }
if (!row.evidence?.sealed || !row.payload?.sealed || row.connection_generation !== generation || row.generation !== generation
|| row.plan_id !== admitted.planId || generation !== admitted.generation || row.operation_id !== admitted.operationName || row.operation_version !== admitted.operationVersion
|| row.policy_version !== admitted.policyVersion || row.evidence.approvalSource !== admitted.approvalSource
|| sha(row.evidence.sealed) !== admitted.evidenceProof || sha(row.payload.sealed) !== admitted.payloadProof) return deny()
const evidence = JSON.parse(await decryptSecret(row.evidence.sealed)) as ChangeEvidence, privateInput = JSON.parse(await decryptSecret(row.payload.sealed)) as Record<string, unknown>
if (!Array.isArray(evidence.steps) || !Array.isArray(evidence.objects) || !Array.isArray(evidence.snapshots) || !privateInput || typeof privateInput !== "object" || Array.isArray(privateInput)) return deny()
const expiresAt = Math.min(originalGrant.admissionExpiresAt, row.expires_at.getTime(), Date.parse(capturedPrincipal.credentialExpiresAt), Date.parse(connection.policy.expiresAt), connection.owner_valid_until.getTime(), evidence.validUntil ? Date.parse(evidence.validUntil) : Infinity)
const metadata = frozen({ operationId, planId: String(row.plan_id), connectionId: capturedPrincipal.connectionId, ownerId: connection.owner_id,
operationName: String(row.operation_id), operationVersion: Number(row.operation_version), policyVersion: Number(row.policy_version), generation, phase: "forward" as const,
approved: !!row.approved_by, ...(admitted.approvalSource && { approvalSource: admitted.approvalSource }), principal: capturedPrincipal, sealedEvidenceProof: sha(row.evidence.sealed), sealedPayloadProof: sha(row.payload.sealed),
originalTemporaryGrantProof: originalGrant.proof, originalTemporaryGrantExpiresAt: originalGrant.expiresAt, originalExpiresAt: expiresAt,
serverIds: [...new Set([...(evidence.target.scope === "servers" ? evidence.target.serverIds : []), ...evidence.objects.flatMap(object => object.serverId === undefined ? [] : [object.serverId])])].sort((a, b) => a - b),
resources: structuredClone(evidence.objects), privateInput, evidence })
entry = { active: false, nonce: admitted.nonce, metadata, grant: frozen({ ...originalGrant }), directory, keyProof, keyEpoch: admitted.keyEpoch,
end: Math.min(originalGrant.admissionMonotonicEnd, performance.now() + Math.max(0, expiresAt - Date.now())), controller: new AbortController() }
const active = entry
const tick = () => { const remaining = Math.min(expiresAt - Date.now(), active.end - performance.now()); if (!Number.isFinite(remaining) || remaining <= 0) active.controller.abort(); else { active.timer = setTimeout(tick, Math.max(1, Math.min(2147483647, remaining))); active.timer.unref() } }
tick()
await current(entry, "pending"); life(entry)
const result = await sql(CLAIM_SQL, [operationId, metadata.planId, metadata.connectionId, entry.nonce, metadata.operationVersion, metadata.policyVersion, generation, metadata.sealedEvidenceProof, metadata.sealedPayloadProof], expiresAt)
if (result.command !== "UPDATE" || !Number.isSafeInteger(result.rowCount) || !Array.isArray(result.rows)) throw Error("Operation claim ACK unavailable")
if (result.rowCount === 0 && result.rows.length === 0) return // No publication; cleanup can close only own still-pending creation, never a rival nonce.
if (result.rowCount !== 1 || result.rows.length !== 1 || result.rows[0].id !== operationId || result.rows[0].plan_id !== metadata.planId || result.rows[0].connection_id !== metadata.connectionId
|| result.rows[0].state !== "running" || result.rows[0].result?.[MCP_OPERATION_PRIVATE_CLAIM_KEY] !== entry.nonce) throw Error("Operation claim ACK mismatch")
life(entry); await current(entry, "running"); life(entry)
entry.active = true
await roots.run(entry, work)
} finally {
if (entry) { entry.active = false; clearTimeout(entry.timer); entry.controller.abort() }
if (interruptOwn) await interruptWithinDatabaseAdmission(admitted)
}
}
export async function captureMcpOperationExecutionOrigin(): Promise<McpOperationExecutionOrigin> {
assertNoOperationConfigurationLockContext(); assertNoConfigurationLockContext()
const entry = roots.getStore(); if (!entry) return deny(); owned(entry)
await current(entry, "running"); owned(entry)
const token = Object.freeze(Object.create(null)) as McpOperationExecutionOrigin; tokens.set(token, entry); return token
}
export async function readCurrentMcpOperationExecutionOrigin(token: unknown): Promise<Readonly<McpOperationExecutionMetadata>> {
const entry = token && typeof token === "object" ? tokens.get(token) : undefined
if (!entry) return deny(); owned(entry); await current(entry, "running"); owned(entry); return entry.metadata
}
export async function inspectMcpOperationExecutionLifetime(token: unknown): Promise<Readonly<{ expiresAt: number; monotonicDeadline: number; signal: AbortSignal }>> {
const entry = token && typeof token === "object" ? tokens.get(token) : undefined
if (!entry) return deny(); owned(entry); await current(entry, "running"); owned(entry)
return Object.freeze({ expiresAt: entry.metadata.originalExpiresAt, monotonicDeadline: entry.end, signal: entry.controller.signal })
}