168 lines
10 KiB
TypeScript
168 lines
10 KiB
TypeScript
/** Shared opt-in v2 I/O. Request budgets own no backend; SQL leases do.
|
|
* Transport and callbacks are trusted source composition, never request JSON. */
|
|
import { AsyncLocalStorage } from "node:async_hooks"
|
|
import type { PoolClient } from "pg"
|
|
import { McpError } from "../modules/mcp/security.js"
|
|
import type { ServerProbeJournal } from "./server-probe-execution.js"
|
|
import { createSqlServerProbeJournal, type ServerProbeJournalContext, type ServerProbeJournalDependencies } from "./server-probe-journal.js"
|
|
import { createServerProbeStorageJournalAdapter } from "./server-probe-storage-journal-adapter.js"
|
|
import { connectProbeStorage } from "./server-probe-storage-connection.js"
|
|
import { ProbeStorageUnknown, validateProbeStoragePolicy, type ProbeStorageConnection, type ProbeStoragePolicy, type ProbeStorageOptions } from "./server-probe-journal-maintenance.js"
|
|
|
|
interface Lease { sql: ProbeStorageConnection; client: Pick<PoolClient, "query">; active: boolean }
|
|
interface RequestWindow extends ProbeStorageOptions { active: boolean; parent?: RequestWindow }
|
|
export type ProbeStorageHostLimits = Omit<ProbeStoragePolicy, "retentionDays">
|
|
export interface ProbeStorageJournalExecution { signal?: AbortSignal; deadlineAt?: number }
|
|
export type ProbeStorageHostJournal = (context: ServerProbeJournalContext, dependencies: Pick<ServerProbeJournalDependencies, "assertAuthority">, execution?: ProbeStorageJournalExecution) => ServerProbeJournal
|
|
const denied = (): never => { throw new McpError("STATE_CONFLICT", "Контекст хранилища диагностики завершён или не подтверждён", 409) }
|
|
const combined = (...values: (AbortSignal | undefined)[]) => {
|
|
const signals = [...new Set(values.filter((value): value is AbortSignal => !!value))]
|
|
return signals.length > 1 ? AbortSignal.any(signals) : signals[0]
|
|
}
|
|
|
|
/** Covers MTU's 260s budget without extending private plan or original authority. */
|
|
export function serverProbeStorageJournalDeadline(authorityExpiresAt: number, preparedExpiresAt: number, now = Date.now()) {
|
|
const deadlineAt = Math.min(now + 300000, authorityExpiresAt, preparedExpiresAt)
|
|
if (![now, authorityExpiresAt, preparedExpiresAt, deadlineAt].every(Number.isSafeInteger) || deadlineAt <= now) return denied()
|
|
return deadlineAt
|
|
}
|
|
|
|
export function createProbeStorageHostIo(limits: ProbeStorageHostLimits, transport: "mcp" | "rest") {
|
|
if (transport !== "mcp" && transport !== "rest") return denied()
|
|
const configured = Object.freeze({ ...limits }), leases = new AsyncLocalStorage<Lease>(), requests = new AsyncLocalStorage<RequestWindow>()
|
|
const storagePolicy = (retention: unknown): ProbeStoragePolicy => validateProbeStoragePolicy({ retention_days: retention,
|
|
global_bytes: configured.globalBytes, owner_bytes: configured.ownerBytes, global_files: configured.globalFiles,
|
|
owner_files: configured.ownerFiles, global_admissions: configured.globalAdmissions, owner_admissions: configured.ownerAdmissions })
|
|
storagePolicy(30)
|
|
const checkWindow = (value: RequestWindow | undefined) => {
|
|
for (let ancestor = value; ancestor; ancestor = ancestor.parent) if (!ancestor.active) return denied()
|
|
return value
|
|
}
|
|
const request = () => checkWindow(requests.getStore())
|
|
const current = () => {
|
|
request()
|
|
const lease = leases.getStore()
|
|
if (lease && !lease.active) return denied()
|
|
return lease
|
|
}
|
|
// This layer owns every backend it acquires. Borrowed planner transactions
|
|
// remain caller-owned and are never silently released or independently raced.
|
|
const owned = async <T>(options: ProbeStorageOptions, work: () => Promise<T>): Promise<T> => {
|
|
if (current()) return denied()
|
|
const ownerWindow = request()
|
|
const physical = await connectProbeStorage(options)
|
|
let inTransaction = false, broken = false
|
|
const sql: ProbeStorageConnection = {
|
|
async query(text, values, queryOptions) {
|
|
checkWindow(ownerWindow)
|
|
if (!lease?.active || broken) return denied()
|
|
if (/^BEGIN\b/i.test(text)) inTransaction = true
|
|
try {
|
|
const result = await physical.query(text, values, queryOptions)
|
|
if (text === "COMMIT" || text === "ROLLBACK") inTransaction = false
|
|
return result
|
|
} catch (error) { broken = true; physical.release(true); throw error }
|
|
},
|
|
release(unsafe) { if (unsafe) { broken = true; physical.release(true) } },
|
|
}
|
|
const lease: Lease = { active: true, sql, client: { query: sql.query as PoolClient["query"] } }
|
|
// Bound the whole fixed callback too: owner checks may await local crypto
|
|
// or revocation files between SQL statements. Late continuations retain an
|
|
// inactive facade and cannot resume SQL after this method has returned.
|
|
let abort!: () => void
|
|
const stopped = new Promise<never>((_resolve, reject) => {
|
|
abort = () => { broken = true; lease.active = false; physical.release(true); reject(new ProbeStorageUnknown()) }
|
|
})
|
|
const timer = setTimeout(abort, Math.max(1, options.deadlineAt - Date.now()))
|
|
options.signal?.addEventListener("abort", abort, { once: true })
|
|
try {
|
|
const completion = Promise.race([Promise.resolve().then(() => {
|
|
checkWindow(ownerWindow)
|
|
if (!lease.active || options.signal?.aborted || Date.now() >= options.deadlineAt) throw new ProbeStorageUnknown()
|
|
return leases.run(lease, work)
|
|
}), stopped])
|
|
if (options.signal?.aborted || Date.now() >= options.deadlineAt) abort()
|
|
const result = await completion
|
|
if (!lease.active || options.signal?.aborted || Date.now() >= options.deadlineAt) { broken = true; throw new ProbeStorageUnknown() }
|
|
return result
|
|
} finally {
|
|
clearTimeout(timer); options.signal?.removeEventListener("abort", abort)
|
|
lease.active = false; physical.release(broken || inTransaction)
|
|
}
|
|
}
|
|
const metadataOptions = (extra?: ProbeStorageOptions): ProbeStorageOptions => {
|
|
const window = request()
|
|
return { deadlineAt: Math.min(Date.now() + 10000, window?.deadlineAt ?? Infinity, extra?.deadlineAt ?? Infinity),
|
|
signal: combined(window?.signal, extra?.signal) }
|
|
}
|
|
const query = async (text: string, values?: unknown[]) => {
|
|
const lease = current()
|
|
return lease ? lease.sql.query(text, values) : owned(metadataOptions(), () => current()!.sql.query(text, values))
|
|
}
|
|
const journal: ProbeStorageHostJournal = (rawContext, dependencies, execution) => {
|
|
if (rawContext.identity.kind !== transport) return denied()
|
|
const context = structuredClone(rawContext), options = { deadlineAt: serverProbeStorageJournalDeadline(context.identity.expiresAt, execution?.deadlineAt ?? NaN), signal: execution?.signal }
|
|
let durable: ServerProbeJournal | undefined, busy = false
|
|
const run = async <T>(quarantine: boolean, work: (value: ServerProbeJournal) => Promise<T>): Promise<T> => {
|
|
if (busy || current()) return denied()
|
|
busy = true
|
|
try {
|
|
// Cleanup deliberately excludes the aborted/expired request window.
|
|
return await owned(quarantine ? { deadlineAt: Date.now() + 10000, signal: AbortSignal.timeout(10000) } : options, async () => {
|
|
if (!durable) {
|
|
const readPolicy = async () => {
|
|
const rows = (await query("SELECT enabled,requests_retention_days FROM mcp_settings WHERE id=1")).rows
|
|
if (rows.length !== 1 || transport === "mcp" && rows[0].enabled !== true) return denied()
|
|
return storagePolicy(rows[0].requests_retention_days)
|
|
}
|
|
const policy = await readPolicy()
|
|
const boundary = createServerProbeStorageJournalAdapter(context, { policy, readPolicy, options,
|
|
assertAuthority: dependencies.assertAuthority,
|
|
connect: async () => { const lease = current(); if (!lease) return denied(); return lease.sql } })
|
|
durable = createSqlServerProbeJournal(context, { assertAuthority: dependencies.assertAuthority, storageBoundary: boundary })
|
|
}
|
|
return work(durable)
|
|
})
|
|
} finally { busy = false }
|
|
}
|
|
return Object.freeze<ServerProbeJournal>({
|
|
claim: value => run(false, actual => actual.claim(value)),
|
|
intent: value => run(false, actual => actual.intent(value)),
|
|
received: value => run(false, actual => actual.received(value)),
|
|
finish: value => run(false, actual => actual.finish(value)),
|
|
quarantine: value => run(true, actual => actual.quarantine(value)),
|
|
read: (receiptId, proof) => run(false, actual => actual.read(receiptId, proof)),
|
|
})
|
|
}
|
|
return {
|
|
query, rows: async (text: string, values: unknown[]) => (await query(text, values)).rows,
|
|
currentClient: () => current()?.client,
|
|
assertOutside() { if (current()) return denied() },
|
|
journal,
|
|
async runRequest<T>(options: ProbeStorageOptions, work: () => Promise<T>): Promise<T> {
|
|
if (current()) return denied()
|
|
const parent = request()
|
|
if (!Number.isSafeInteger(options.deadlineAt)) return denied()
|
|
const window: RequestWindow = { active: true, parent,
|
|
deadlineAt: Math.min(options.deadlineAt, Date.now() + 300000, parent?.deadlineAt ?? Infinity),
|
|
signal: combined(options.signal, parent?.signal) }
|
|
try { return await requests.run(window, work) } finally { window.active = false }
|
|
},
|
|
async withClient<T>(work: (client: Pick<PoolClient, "query">) => Promise<T>, options?: ProbeStorageOptions): Promise<T> {
|
|
const lease = current()
|
|
return lease ? work(lease.client) : owned(metadataOptions(options), () => work(current()!.client))
|
|
},
|
|
async withBorrowed<T>(client: Pick<PoolClient, "query">, work: () => Promise<T>): Promise<T> {
|
|
if (current()) return denied()
|
|
const ownerWindow = request()
|
|
const sql: ProbeStorageConnection = { query: (text, values) => {
|
|
checkWindow(ownerWindow)
|
|
if (!lease.active) return denied()
|
|
return client.query(text, values)
|
|
}, release: () => denied() }
|
|
const lease: Lease = { active: true, client: { query: sql.query as PoolClient["query"] }, sql }
|
|
try { return await leases.run(lease, work) } finally { lease.active = false }
|
|
},
|
|
}
|
|
}
|