/** Private codec only. A future caller must own a bounded, locked SQL * snapshot, and readers must still prove current scope and protections. */ import { createHash } from "node:crypto" import { z } from "zod" import { authenticateServerProbeExecutionSourceRow } from "../modules/mcp/diagnostic-cancellation-source.js" import { serverProbeReceiptMetadata } from "../modules/mcp/server-probe-actions.js" import { serviceDiagnosticReceipt } from "../modules/mcp/service-diagnostic-progress.js" import { constantEqual, decryptSecretExisting, fingerprint, privateFingerprinterExisting } from "../modules/mcp/security.js" import { createLegacyServerProbeVerifier } from "./server-probe-legacy-verifier.js" import { validateServerProbeJournalReceipt } from "./server-probe-journal.js" import type { ServerProbeReceipt } from "./server-probe-execution.js" import { canonicalPollArchiveTimestamp } from "./server-poll-terminal-archive.js" const purpose="server-probe-retired-source-v1" const uuid=z.string().uuid(),hash=z.string().regex(/^[0-9a-f]{64}$/),sid=z.number().int().positive().safe() const time=z.string().transform(canonicalPollArchiveTimestamp) const tool=z.enum(["ping","traceroute","bandwidth","dns","route","mtu"]) const record=z.record(z.string(),z.unknown()) const originalSchema=z.object({ operation_id:uuid,connection_id:uuid,owner_id:z.string().min(1).max(200),plan_id:uuid, operation_name:z.literal("servers.probes.run"),operation_version:z.literal(1),operation_state:z.literal("applied"), operation_verification:z.literal("inconclusive"),operation_error_code:z.null(),operation_result:z.unknown(), plan_state:z.literal("completed"),approved_by:z.string().min(1).max(200),evidence:record, step_index:z.literal(0),step_state:z.literal("acknowledged"),intended_state:record,step_result:record, operation_created_at:time,operation_finished_at:time,plan_created_at:time,plan_approved_at:time, plan_expires_at:time,step_created_at:time,step_finished_at:time, }).strict() const admissionSchema=z.object({ receipt_id:uuid,owner_id:z.string().min(1).max(200),identity_kind:z.literal("mcp"),execution_id:uuid,binding_proof:hash, authority_expires_at:time,claim_token:z.null(),claim_attempted_at:time,purged_at:z.null(),cancelled_at:z.null(),created_at:time, retention_days:z.number().int().min(1).max(365),safety_ms:z.number().int().min(60000).max(86400000),gc_not_before:time, }).strict() const sourceSchema=z.object({ original:originalSchema,admission:admissionSchema,anchor:record, payload:z.object({receipt_id:uuid,receipt_proof:hash,receipt_ciphertext:z.string().min(1).max(262144)}).strict(), stages:z.array(record).min(1).max(11),quarantineCount:z.literal(0),cancellationCount:z.literal(0), }).strict() const signedSchema=z.object({ version:z.literal(1),receiptId:uuid,executionId:uuid,connectionId:uuid,ownerId:z.string().min(1).max(200),planId:uuid, operation:z.literal("servers.probes.run"),operationVersion:z.literal(1),originalCredentialId:uuid, sourceServerId:sid,destinationServerId:sid.optional(),tool,serverIds:z.array(sid).min(1).max(2), issuedAt:z.number().int().nonnegative().safe(),authorityExpiresAt:time,terminalAt:time,activityAt:time,gcNotBefore:time, retentionDays:z.number().int().min(1).max(365),safetyMs:z.number().int().min(60000).max(86400000), bindingProof:hash,sourceDigest:hash,terminalDigest:hash,stageSnapshotDigest:hash,receiptProof:hash,ciphertextSha256:hash, }).strict().refine(value=>{ const expected=[...new Set([value.sourceServerId,...(value.destinationServerId===undefined?[]:[value.destinationServerId])])].sort((a,b)=>a-b) return fingerprint(expected)===fingerprint(value.serverIds) && (value.tool==="bandwidth" ? value.destinationServerId!==undefined&&value.destinationServerId!==value.sourceServerId : value.destinationServerId===undefined) && value.issuedAt=micros(value.authorityExpiresAt)+BigInt(value.retentionDays*86400000+value.safetyMs)*1000n }) export type ServerProbeRetiredSource = z.output /** Match the exact canonical live terminal projection after payload expiry. */ export function matchesServerProbeRetiredTerminal(source: ServerProbeRetiredSource, raw: unknown): boolean { const parsed = originalSchema.safeParse(raw) return parsed.success && parsed.data.operation_id === source.executionId && parsed.data.plan_id === source.planId && parsed.data.connection_id === source.connectionId && parsed.data.owner_id === source.ownerId && fingerprint(parsed.data) === source.terminalDigest } export interface SignedServerProbeRetiredSource { source: ServerProbeRetiredSource; proof: string } export class ServerProbeRetirementSourceRefused extends Error { readonly automaticReplay=false constructor(){super("Diagnostic retirement source cannot be authenticated");this.name="ServerProbeRetirementSourceRefused"} } function requireThat(value:unknown):asserts value {if(!value)throw new ServerProbeRetirementSourceRefused()} function micros(value:string){return BigInt(Date.parse(value))*1000n+BigInt(value.slice(23,26))} const maximum=(...values:string[])=>values.sort().at(-1)! /** Produces no operation/payload/cancellation mutation or public authorization. * Only settled successful sources with the original retained payload qualify. */ export async function projectServerProbeRetiredSource(raw:unknown):Promise{ try{ requireThat(Buffer.byteLength(JSON.stringify(raw))<=3*1048576) const source=sourceSchema.parse(structuredClone(raw)),{original,admission,anchor,payload,stages}=source const authenticated=await authenticateServerProbeExecutionSourceRow(original,original.operation_id, {connectionId:original.connection_id,ownerId:original.owner_id}) requireThat(authenticated.terminal&&authenticated.sourceState==="applied") const context=authenticated.originalContext,id=context.identity requireThat(admission.receipt_id===authenticated.scope.receiptId&&admission.execution_id===id.executionId&& admission.owner_id===id.ownerId&&admission.binding_proof===authenticated.scope.bindingProof&& micros(admission.authority_expires_at)===BigInt(id.expiresAt)*1000n&&time.parse(anchor.authority_expires_at)===admission.authority_expires_at&& payload.receipt_id===admission.receipt_id&& payload.receipt_proof===anchor.receipt_proof&&anchor.state==="completed") const verify=createLegacyServerProbeVerifier({loadMcpSource:async operationId=>{ requireThat(operationId===id.executionId) return authenticated }}) const verified=await verify({identityKind:"mcp",executionId:id.executionId, anchor:{...anchor,receipt_ciphertext:payload.receipt_ciphertext},stages}) requireThat(verified.status==="verified"&&verified.authentication==="receipt"&&verified.bindingAuthenticated&& verified.progressAuthenticated&&verified.terminal&&!verified.quarantined&&!verified.cancelled) // The same ciphertext has already passed the existing receipt MAC and // original-context checks above. Match its actual public effect as well. const envelope=JSON.parse(await decryptSecretExisting(payload.receipt_ciphertext)) as {receipt:ServerProbeReceipt} const receipt=validateServerProbeJournalReceipt(context,admission.receipt_id,envelope.receipt) requireThat(receipt.state==="completed") const metadata=serverProbeReceiptMetadata(receipt,id.executionId,authenticated.stageBudget) const confirmed=serviceDiagnosticReceipt(metadata,true,id.executionId,authenticated.stageBudget) requireThat(confirmed&&fingerprint(original.step_result)===fingerprint(metadata)&&fingerprint(original.operation_result)===fingerprint({ confirmedWrites:0,verificationScope:"acknowledgement",completedServiceSteps:1,diagnosticReceipt:confirmed, })) // The original receipt authenticates context and progress, not SQL row // timestamps. Sign the exact observed locked snapshot and its chronology, // without upgrading the historical journal's stage or timestamp proofs. const anchorCreated=time.parse(anchor.created_at),anchorFinished=time.parse(anchor.finished_at) requireThat(original.plan_created_at<=original.plan_approved_at&&original.plan_approved_at<=original.operation_created_at&& original.operation_created_at{ try{ requireThat(Buffer.byteLength(JSON.stringify(raw))<=8192) const {source,proof}=z.object({source:signedSchema,proof:hash}).strict().parse(structuredClone(raw)) const sign=await privateFingerprinterExisting(purpose) requireThat(constantEqual(proof,sign(fingerprint(source)))) return source }catch{throw new ServerProbeRetirementSourceRefused()} }