@1mcp/agent 0.34.4 → 0.35.0-beta.2

package/build/domains/admin/adminOperationService.js

@@ -0,0 +1,749 @@
+import { createHash, createHmac, randomUUID } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+const ADMIN_STATE_DIR = 'admin';
+const JOURNAL_VERSION = 1;
+const DEFAULT_COMPLETED_RETENTION_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_AUDIT_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+const DEFAULT_IN_FLIGHT_WAIT_MS = 100;
+const runtimeScopeMutationStates = new Map();
+export class AdminOperationService {
+    runtimeScopeId;
+    storageDir;
+    now;
+    completedRetentionMs;
+    auditRetentionMs;
+    inFlightWaitMs;
+    createOperationId;
+    mutationAvailability;
+    idempotency;
+    recentAuditFacts;
+    mutationState;
+    constructor(options) {
+        this.runtimeScopeId = options.runtimeScopeId;
+        this.storageDir = path.join(options.storageDir, ADMIN_STATE_DIR);
+        this.now = options.now ?? (() => new Date());
+        this.completedRetentionMs = options.completedRetentionMs ?? DEFAULT_COMPLETED_RETENTION_MS;
+        this.auditRetentionMs = options.auditRetentionMs ?? DEFAULT_AUDIT_RETENTION_MS;
+        this.inFlightWaitMs = options.inFlightWaitMs ?? DEFAULT_IN_FLIGHT_WAIT_MS;
+        this.createOperationId = options.createOperationId ?? (() => `op_${randomUUID()}`);
+        this.mutationAvailability = options.mutationAvailability ?? { available: true };
+        this.mutationState = getRuntimeScopeMutationState(this.storageDir, this.runtimeScopeId);
+        this.idempotency = this.mutationState.idempotency;
+        this.recentAuditFacts = this.mutationState.recentAuditFacts;
+        this.replayJournal();
+    }
+    async executeReadOnly(input) {
+        const result = await input.run(input.context);
+        return {
+            ok: true,
+            status: 'completed',
+            operationId: this.createOperationId(),
+            operationName: input.operationName,
+            result,
+            replayed: false,
+        };
+    }
+    async executeDryRun(input) {
+        const admissionResult = this.validateRuntimeScope(input.context, input.operationName);
+        if (admissionResult) {
+            return admissionResult;
+        }
+        try {
+            const result = await input.run(input.context);
+            return {
+                ok: true,
+                status: 'completed',
+                operationId: this.createOperationId(),
+                operationName: input.operationName,
+                result,
+                replayed: false,
+            };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                status: 'mutation_failed',
+                code: 'mutation_failed',
+                retryable: false,
+                operationName: input.operationName,
+                error: error instanceof Error ? error.message : 'Admin dry-run failed',
+            };
+        }
+    }
+    getRecentAuditFacts(options = {}) {
+        const limit = Math.max(0, options.limit ?? this.recentAuditFacts.length);
+        if (limit === 0) {
+            return [];
+        }
+        return this.recentAuditFacts.slice(-limit).map((fact) => ({
+            ...fact,
+            actor: { ...fact.actor },
+            target: { ...fact.target },
+            request: { ...fact.request },
+            confirmationFacts: fact.confirmationFacts ? { ...fact.confirmationFacts } : undefined,
+        }));
+    }
+    async executeMutation(input) {
+        const admissionResult = this.validateMutationAdmission(input.context, input.operationName);
+        if (admissionResult) {
+            return admissionResult;
+        }
+        if (this.mutationState.journalUnavailable) {
+            return this.journalUnavailableResult(input.operationName);
+        }
+        const idempotencyKey = input.context.idempotencyKey?.trim();
+        const requestFingerprint = input.context.requestFingerprint?.trim();
+        if (!idempotencyKey || !requestFingerprint) {
+            return {
+                ok: false,
+                status: 'idempotency_key_required',
+                code: 'idempotency_key_required',
+                retryable: false,
+                operationName: input.operationName,
+            };
+        }
+        const scopedKeyHash = this.scopedKeyHash(input.context, input.operationName, idempotencyKey);
+        const legacyScopedKeyHash = this.legacyScopedKeyHash(input.context, input.operationName, idempotencyKey);
+        const fingerprintHash = keyedSecretFingerprint(idempotencyKey, 'request', requestFingerprint);
+        const legacyFingerprintHash = legacySecretHash(requestFingerprint);
+        let existingKeyHash = scopedKeyHash;
+        let existing = this.idempotency.get(existingKeyHash);
+        if (!existing) {
+            existingKeyHash = legacyScopedKeyHash;
+            existing = this.idempotency.get(existingKeyHash);
+        }
+        if (existing && this.isExpiredTerminal(existing)) {
+            this.idempotency.delete(existingKeyHash);
+            existing = undefined;
+        }
+        if (existing &&
+            existing.fingerprintHash !== fingerprintHash &&
+            existing.fingerprintHash !== legacyFingerprintHash) {
+            return {
+                ok: false,
+                status: 'idempotency_conflict',
+                code: 'idempotency_conflict',
+                retryable: false,
+                operationName: input.operationName,
+            };
+        }
+        if (existing?.state === 'completed' && !this.isExpired(existing.completedAt ?? existing.reservedAt)) {
+            return {
+                ok: true,
+                status: 'completed',
+                operationId: existing.operationId,
+                operationName: input.operationName,
+                result: existing.result,
+                replayed: true,
+            };
+        }
+        if (existing?.state === 'failed' && !this.isExpired(existing.completedAt ?? existing.reservedAt)) {
+            return {
+                ok: false,
+                status: 'mutation_failed',
+                code: 'mutation_failed',
+                retryable: false,
+                operationName: existing.operationName,
+                error: existing.error ?? 'Admin operation failed',
+            };
+        }
+        if (existing?.state === 'state_unknown') {
+            return this.stateUnknownResult(existing);
+        }
+        if (existing?.state === 'in_flight') {
+            return (await this.waitForActiveMutation(existingKeyHash, input.operationName));
+        }
+        const activePreparation = this.mutationState.activePreparations.get(scopedKeyHash);
+        if (activePreparation) {
+            if (activePreparation.fingerprintHash !== fingerprintHash) {
+                return {
+                    ok: false,
+                    status: 'idempotency_conflict',
+                    code: 'idempotency_conflict',
+                    retryable: false,
+                    operationName: input.operationName,
+                };
+            }
+            return (await this.waitForActivePreparation(activePreparation, input.operationName));
+        }
+        const preparationPromise = this.prepareAndExecuteMutation(input, scopedKeyHash, fingerprintHash);
+        this.mutationState.activePreparations.set(scopedKeyHash, {
+            fingerprintHash,
+            promise: preparationPromise,
+        });
+        try {
+            return await preparationPromise;
+        }
+        finally {
+            const active = this.mutationState.activePreparations.get(scopedKeyHash);
+            if (active?.promise === preparationPromise) {
+                this.mutationState.activePreparations.delete(scopedKeyHash);
+            }
+        }
+    }
+    async prepareAndExecuteMutation(input, scopedKeyHash, fingerprintHash) {
+        const prepared = 'prepare' in input ? await input.prepare() : input;
+        const readyInput = {
+            context: input.context,
+            operationName: input.operationName,
+            confirmationRequirements: prepared.confirmationRequirements,
+            run: prepared.run,
+        };
+        const confirmationResult = this.validateConfirmations(readyInput);
+        if (confirmationResult) {
+            return confirmationResult;
+        }
+        const operationId = this.createOperationId();
+        const reservedAt = this.now().toISOString();
+        const entry = {
+            state: 'in_flight',
+            scopedKeyHash,
+            fingerprintHash,
+            operationId,
+            operationName: input.operationName,
+            target: sanitizeTarget(input.context.target),
+            reservedAt,
+        };
+        try {
+            this.appendJournalRecord(this.reservedRecord(input.context, input.operationName, entry));
+        }
+        catch {
+            this.idempotency.delete(scopedKeyHash);
+            this.mutationState.journalUnavailable = true;
+            return this.journalUnavailableResult(input.operationName);
+        }
+        this.idempotency.set(scopedKeyHash, entry);
+        const activePromise = this.enqueueMutation(async () => this.runReservedMutation(readyInput, entry));
+        this.mutationState.activeMutations.set(scopedKeyHash, {
+            promise: activePromise,
+        });
+        activePromise.finally(() => {
+            this.mutationState.activeMutations.delete(scopedKeyHash);
+        });
+        return (await activePromise);
+    }
+    async waitForActivePreparation(active, operationName) {
+        const timeoutMs = this.retryWaitMs();
+        const timeout = new Promise((resolve) => {
+            setTimeout(() => resolve(this.operationInProgress(operationName, timeoutMs)), timeoutMs);
+        });
+        return Promise.race([active.promise, timeout]);
+    }
+    validateMutationAdmission(context, operationName) {
+        const runtimeScopeResult = this.validateRuntimeScope(context, operationName);
+        if (runtimeScopeResult)
+            return runtimeScopeResult;
+        if (!this.mutationAvailability.available) {
+            return {
+                ok: false,
+                status: 'runtime_scope_locked',
+                code: 'runtime_scope_locked',
+                retryable: true,
+                operationName,
+                reason: 'writer_lock_unavailable',
+            };
+        }
+        return null;
+    }
+    validateRuntimeScope(context, operationName) {
+        if (context.runtimeIdentity.runtimeScopeId === this.runtimeScopeId)
+            return null;
+        return {
+            ok: false,
+            status: 'runtime_scope_mismatch',
+            code: 'runtime_scope_mismatch',
+            retryable: false,
+            operationName,
+        };
+    }
+    async runReservedMutation(input, entry) {
+        let result;
+        try {
+            result = await input.run(input.context);
+        }
+        catch (error) {
+            return this.recordMutationFailure(input, entry, error);
+        }
+        const completedAt = this.now().toISOString();
+        const completedEntry = {
+            ...entry,
+            state: 'completed',
+            completedAt,
+            result,
+        };
+        try {
+            this.appendJournalRecord({
+                schemaVersion: JOURNAL_VERSION,
+                type: 'completed',
+                runtimeScopeId: this.runtimeScopeId,
+                timestamp: completedAt,
+                operationId: entry.operationId,
+                operationName: entry.operationName,
+                scopedKeyHash: entry.scopedKeyHash,
+                fingerprintHash: entry.fingerprintHash,
+                result,
+            });
+            this.appendAuditRecord(input.context, entry, 'completed');
+            this.idempotency.set(entry.scopedKeyHash, completedEntry);
+            return {
+                ok: true,
+                status: 'completed',
+                operationId: entry.operationId,
+                operationName: entry.operationName,
+                result,
+                replayed: false,
+            };
+        }
+        catch {
+            return this.markStateUnknownResult(entry);
+        }
+    }
+    recordMutationFailure(input, entry, error) {
+        const failedAt = this.now().toISOString();
+        const message = error instanceof Error ? error.message : 'Admin operation failed';
+        try {
+            this.appendJournalRecord({
+                schemaVersion: JOURNAL_VERSION,
+                type: 'failed',
+                runtimeScopeId: this.runtimeScopeId,
+                timestamp: failedAt,
+                operationId: entry.operationId,
+                operationName: entry.operationName,
+                scopedKeyHash: entry.scopedKeyHash,
+                fingerprintHash: entry.fingerprintHash,
+                error: message,
+            });
+            this.appendAuditRecord(input.context, entry, 'failed');
+            this.idempotency.set(entry.scopedKeyHash, {
+                ...entry,
+                state: 'failed',
+                completedAt: failedAt,
+                error: message,
+            });
+        }
+        catch {
+            this.mutationState.journalUnavailable = true;
+            return this.journalUnavailableResult(entry.operationName);
+        }
+        return {
+            ok: false,
+            status: 'mutation_failed',
+            code: 'mutation_failed',
+            retryable: false,
+            operationName: entry.operationName,
+            error: message,
+        };
+    }
+    enqueueMutation(operation) {
+        const run = this.mutationState.mutationQueue.then(operation, operation);
+        this.mutationState.mutationQueue = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    async waitForActiveMutation(scopedKeyHash, operationName) {
+        const active = this.mutationState.activeMutations.get(scopedKeyHash);
+        if (!active) {
+            const entry = this.idempotency.get(scopedKeyHash);
+            return entry ? this.markStateUnknownResult(entry) : this.operationInProgress(operationName);
+        }
+        const timeoutMs = this.retryWaitMs();
+        const timeout = new Promise((resolve) => {
+            setTimeout(() => resolve(this.operationInProgress(operationName, timeoutMs)), timeoutMs);
+        });
+        return Promise.race([active.promise, timeout]);
+    }
+    retryWaitMs() {
+        return Math.max(1, this.inFlightWaitMs);
+    }
+    operationInProgress(operationName, retryAfterMs = this.retryWaitMs()) {
+        return {
+            ok: false,
+            status: 'operation_in_progress',
+            code: 'operation_in_progress',
+            retryable: true,
+            operationName,
+            retryAfterMs,
+        };
+    }
+    journalUnavailableResult(operationName) {
+        return {
+            ok: false,
+            status: 'admin_operation_journal_unavailable',
+            code: 'admin_operation_journal_unavailable',
+            retryable: false,
+            operationName,
+        };
+    }
+    validateConfirmations(input) {
+        if (!input.confirmationRequirements?.length) {
+            return null;
+        }
+        const facts = input.context.confirmationFacts ?? {};
+        const missing = input.confirmationRequirements.filter((requirement) => {
+            const actual = facts[requirement.code];
+            return requirement.expected === undefined ? actual !== true : actual !== requirement.expected;
+        });
+        if (missing.length === 0) {
+            return null;
+        }
+        return {
+            ok: false,
+            status: 'mutation_confirmation_required',
+            code: 'mutation_confirmation_required',
+            retryable: false,
+            operationName: input.operationName,
+            confirmationRequirements: input.confirmationRequirements.map((requirement) => ({ ...requirement })),
+        };
+    }
+    replayJournal() {
+        const filePath = this.journalFilePath();
+        if (!fs.existsSync(filePath)) {
+            return;
+        }
+        try {
+            const records = this.readJournalRecords(filePath);
+            this.idempotency.clear();
+            this.recentAuditFacts.length = 0;
+            this.mutationState.journalUnavailable = false;
+            for (const record of records) {
+                this.applyJournalRecord(record);
+            }
+            for (const entry of Array.from(this.idempotency.values())) {
+                if (entry.state === 'in_flight' && !this.mutationState.activeMutations.has(entry.scopedKeyHash)) {
+                    this.markStateUnknown(entry);
+                }
+            }
+        }
+        catch {
+            this.idempotency.clear();
+            this.recentAuditFacts.length = 0;
+            this.mutationState.journalUnavailable = true;
+            return;
+        }
+        try {
+            this.compactJournal();
+        }
+        catch {
+            // Compaction is cleanup only; replayed admission/audit state remains authoritative.
+        }
+    }
+    applyJournalRecord(record) {
+        if (record.schemaVersion !== JOURNAL_VERSION || record.runtimeScopeId !== this.runtimeScopeId) {
+            return;
+        }
+        if (record.type === 'reserved') {
+            this.idempotency.set(record.scopedKeyHash, {
+                state: 'in_flight',
+                scopedKeyHash: record.scopedKeyHash,
+                fingerprintHash: record.fingerprintHash,
+                operationId: record.operationId,
+                operationName: record.operationName,
+                target: record.target,
+                reservedAt: record.timestamp,
+            });
+            return;
+        }
+        if (record.type === 'completed') {
+            if (this.isExpired(record.timestamp)) {
+                this.idempotency.delete(record.scopedKeyHash);
+                return;
+            }
+            this.idempotency.set(record.scopedKeyHash, {
+                ...this.entryFromRecord(record),
+                state: 'completed',
+                completedAt: record.timestamp,
+                result: record.result,
+            });
+            return;
+        }
+        if (record.type === 'failed') {
+            if (this.isExpired(record.timestamp)) {
+                this.idempotency.delete(record.scopedKeyHash);
+                return;
+            }
+            this.idempotency.set(record.scopedKeyHash, {
+                ...this.entryFromRecord(record),
+                state: 'failed',
+                completedAt: record.timestamp,
+                error: record.error,
+            });
+            return;
+        }
+        if (record.type === 'state_unknown') {
+            if (this.isAuditExpired(record.timestamp)) {
+                this.idempotency.delete(record.scopedKeyHash);
+                return;
+            }
+            this.idempotency.set(record.scopedKeyHash, {
+                state: 'state_unknown',
+                scopedKeyHash: record.scopedKeyHash,
+                fingerprintHash: record.fingerprintHash,
+                operationId: record.operationId,
+                operationName: record.operationName,
+                target: record.target,
+                reservedAt: record.reservedAt,
+            });
+            return;
+        }
+        if (record.type === 'audit') {
+            if (this.isAuditExpired(record.timestamp)) {
+                return;
+            }
+            this.recentAuditFacts.push(auditFactFromRecord(record));
+        }
+    }
+    entryFromRecord(record) {
+        const existing = this.idempotency.get(record.scopedKeyHash);
+        return {
+            scopedKeyHash: record.scopedKeyHash,
+            fingerprintHash: record.fingerprintHash,
+            operationId: record.operationId,
+            operationName: record.operationName,
+            target: existing?.target ?? { type: 'unknown' },
+            reservedAt: existing?.reservedAt ?? record.timestamp,
+        };
+    }
+    markStateUnknown(entry) {
+        const unknownEntry = {
+            ...entry,
+            state: 'state_unknown',
+        };
+        this.appendJournalRecord({
+            schemaVersion: JOURNAL_VERSION,
+            type: 'state_unknown',
+            runtimeScopeId: this.runtimeScopeId,
+            timestamp: this.now().toISOString(),
+            operationId: entry.operationId,
+            operationName: entry.operationName,
+            scopedKeyHash: entry.scopedKeyHash,
+            fingerprintHash: entry.fingerprintHash,
+            target: entry.target,
+            reservedAt: entry.reservedAt,
+        });
+        this.idempotency.set(entry.scopedKeyHash, unknownEntry);
+        return unknownEntry;
+    }
+    markStateUnknownResult(entry) {
+        try {
+            return this.stateUnknownResult(this.markStateUnknown(entry));
+        }
+        catch {
+            this.mutationState.journalUnavailable = true;
+            this.idempotency.set(entry.scopedKeyHash, {
+                ...entry,
+                state: 'state_unknown',
+            });
+            return this.journalUnavailableResult(entry.operationName);
+        }
+    }
+    stateUnknownResult(entry) {
+        return {
+            ok: false,
+            status: 'operation_state_unknown',
+            code: 'operation_state_unknown',
+            retryable: false,
+            operationName: entry.operationName,
+            target: entry.target,
+            reservedAt: entry.reservedAt,
+            recovery: 'inspect_current_state_and_retry_with_new_idempotency_key',
+        };
+    }
+    reservedRecord(context, operationName, entry) {
+        return {
+            schemaVersion: JOURNAL_VERSION,
+            type: 'reserved',
+            runtimeScopeId: this.runtimeScopeId,
+            timestamp: entry.reservedAt,
+            operationId: entry.operationId,
+            operationName,
+            scopedKeyHash: entry.scopedKeyHash,
+            fingerprintHash: entry.fingerprintHash,
+            target: entry.target,
+            actor: sanitizeActor(context.actor, this.runtimeScopeId),
+            origin: context.origin,
+            request: sanitizeRequest(context.request),
+            runtimeIdentity: sanitizeRuntimeIdentity(context.runtimeIdentity),
+        };
+    }
+    appendAuditRecord(context, entry, result) {
+        const fact = {
+            timestamp: this.now().toISOString(),
+            operationId: entry.operationId,
+            operationName: entry.operationName,
+            result,
+            actor: sanitizeActor(context.actor, this.runtimeScopeId),
+            origin: context.origin,
+            target: entry.target,
+            request: { requestId: context.request.requestId },
+            confirmationFacts: sanitizeConfirmationFacts(context.confirmationFacts),
+        };
+        this.appendJournalRecord({
+            schemaVersion: JOURNAL_VERSION,
+            type: 'audit',
+            runtimeScopeId: this.runtimeScopeId,
+            timestamp: fact.timestamp,
+            operationId: fact.operationId,
+            operationName: fact.operationName,
+            scopedKeyHash: entry.scopedKeyHash,
+            result: fact.result,
+            actor: fact.actor,
+            origin: fact.origin,
+            target: fact.target,
+            request: fact.request,
+            confirmationFacts: fact.confirmationFacts,
+        });
+        this.recentAuditFacts.push(fact);
+    }
+    appendJournalRecord(record) {
+        fs.mkdirSync(this.storageDir, { recursive: true });
+        const filePath = this.journalFilePath();
+        const fd = fs.openSync(filePath, 'a', 0o600);
+        try {
+            fs.chmodSync(filePath, 0o600);
+            fs.writeSync(fd, `${JSON.stringify(record)}\n`, undefined, 'utf8');
+            fs.fsyncSync(fd);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    scopedKeyHash(context, operationName, idempotencyKey) {
+        return keyedSecretFingerprint(idempotencyKey, 'idempotency-scope', JSON.stringify({
+            runtimeScopeId: this.runtimeScopeId,
+            actorType: context.actor.type,
+            accountId: context.actor.accountId,
+            sessionId: context.actor.sessionId,
+            operationName,
+        }));
+    }
+    legacyScopedKeyHash(context, operationName, idempotencyKey) {
+        return legacySecretHash(JSON.stringify({
+            runtimeScopeId: this.runtimeScopeId,
+            actorType: context.actor.type,
+            accountId: context.actor.accountId,
+            sessionId: context.actor.sessionId,
+            operationName,
+            idempotencyKey,
+        }));
+    }
+    isExpired(timestamp) {
+        return this.now().getTime() - new Date(timestamp).getTime() > this.completedRetentionMs;
+    }
+    isAuditExpired(timestamp) {
+        return this.now().getTime() - new Date(timestamp).getTime() > this.auditRetentionMs;
+    }
+    isExpiredTerminal(entry) {
+        return ((entry.state === 'completed' || entry.state === 'failed') && this.isExpired(entry.completedAt ?? entry.reservedAt));
+    }
+    compactJournal() {
+        const filePath = this.journalFilePath();
+        if (!fs.existsSync(filePath)) {
+            return;
+        }
+        const records = this.readJournalRecords(filePath);
+        const retained = records.filter((record) => this.shouldRetainJournalRecord(record));
+        if (retained.length === records.length) {
+            return;
+        }
+        const tempPath = `${filePath}.${process.pid}.compact.tmp`;
+        const content = retained.length > 0 ? `${retained.map((record) => JSON.stringify(record)).join('\n')}\n` : '';
+        fs.writeFileSync(tempPath, content, { encoding: 'utf8', mode: 0o600 });
+        fs.renameSync(tempPath, filePath);
+        fs.chmodSync(filePath, 0o600);
+    }
+    shouldRetainJournalRecord(record) {
+        if (record.type === 'state_unknown') {
+            return !this.isAuditExpired(record.timestamp);
+        }
+        if (record.type === 'audit') {
+            return !this.isAuditExpired(record.timestamp);
+        }
+        if (record.type === 'completed' || record.type === 'failed') {
+            return !this.isExpired(record.timestamp);
+        }
+        const entry = this.idempotency.get(record.scopedKeyHash);
+        return Boolean(entry && !this.isExpiredTerminal(entry));
+    }
+    readJournalRecords(filePath) {
+        return fs
+            .readFileSync(filePath, 'utf8')
+            .split('\n')
+            .filter((line) => line.trim())
+            .map((line) => JSON.parse(line));
+    }
+    journalFilePath() {
+        return path.join(this.storageDir, `admin-operations-${stableIdentifierHash(this.runtimeScopeId).slice(0, 24)}.jsonl`);
+    }
+}
+function sanitizeActor(actor, runtimeScopeId) {
+    return {
+        type: actor.type,
+        accountIdHash: keyedSecretFingerprint(runtimeScopeId, 'account-id', actor.accountId),
+        sessionIdHash: actor.sessionId ? keyedSecretFingerprint(runtimeScopeId, 'session-id', actor.sessionId) : undefined,
+    };
+}
+function sanitizeTarget(target) {
+    return {
+        type: target.type,
+        id: target.id,
+    };
+}
+function sanitizeRequest(request) {
+    return {
+        requestId: request.requestId,
+        jsonMode: request.jsonMode,
+    };
+}
+function sanitizeRuntimeIdentity(runtimeIdentity) {
+    return {
+        runtimeScopeId: runtimeIdentity.runtimeScopeId,
+        runtimeVersion: runtimeIdentity.runtimeVersion,
+    };
+}
+function sanitizeConfirmationFacts(facts) {
+    if (!facts || Object.keys(facts).length === 0) {
+        return undefined;
+    }
+    return Object.fromEntries(Object.entries(facts).filter(([, value]) => ['string', 'boolean', 'number'].includes(typeof value)));
+}
+function stableIdentifierHash(identifier) {
+    return createHash('sha256').update(identifier).digest('base64url');
+}
+// Retained v1 journal entries use unkeyed SHA-256. Keep this only for bounded replay compatibility.
+function legacySecretHash(secret) {
+    return createHash('sha256').update(secret).digest('base64url');
+}
+function keyedSecretFingerprint(key, domain, secret) {
+    return createHmac('sha256', key).update(domain).update('\0').update(secret).digest('base64url');
+}
+function auditFactFromRecord(record) {
+    return {
+        timestamp: record.timestamp,
+        operationId: record.operationId,
+        operationName: record.operationName,
+        result: record.result,
+        actor: { ...record.actor },
+        origin: record.origin,
+        target: { ...record.target },
+        request: { ...record.request },
+        confirmationFacts: record.confirmationFacts ? { ...record.confirmationFacts } : undefined,
+    };
+}
+function getRuntimeScopeMutationState(storageDir, runtimeScopeId) {
+    const key = `${storageDir}\0${runtimeScopeId}`;
+    const existing = runtimeScopeMutationStates.get(key);
+    if (existing) {
+        return existing;
+    }
+    const state = {
+        mutationQueue: Promise.resolve(),
+        activeMutations: new Map(),
+        activePreparations: new Map(),
+        idempotency: new Map(),
+        recentAuditFacts: [],
+        journalUnavailable: false,
+    };
+    runtimeScopeMutationStates.set(key, state);
+    return state;
+}
+//# sourceMappingURL=adminOperationService.js.map