openclaw/dist/config/sessions/session-lifecycle-projection.worker.js

Multi-channel AI gateway with extensible messaging integrations

import { r as runSqliteDeferredTransactionSync, t as assertTransactionUsable } from "../../sqlite-transaction-DBRLvCDM.mjs";
import { a as readOpenClawAgentDatabaseIdentity } from "../../openclaw-agent-db-identity-BlmER9-X.mjs";
import { i as getSqliteWorkerStateContext } from "../../sqlite-worker-state-context-G3Xbcj1W.mjs";
import { i as getOpenClawAgentDatabaseIfOpen } from "../../openclaw-agent-db-DWI9Bgur.mjs";
import { n as readSessionEntryCount, r as readSessionEntryStore } from "../../session-accessor.sqlite-entry-inventory-DeyJmBYs.mjs";
import { t as collectLifecycleIdentityChanges } from "../../session-accessor.sqlite-identity-BZB1295A.mjs";
import "../../session-accessor.sqlite-entry-store-CIM2yoGL.mjs";
import { n as hasPendingSessionTranscriptArchives } from "../../session-accessor.sqlite-archive-store-kernel-LqEJdBnu.mjs";
import { m as selectProjectedLifecycleRemovals, s as finishProjectedLifecycleRemovalPlans } from "../../session-accessor.sqlite-lifecycle-state-Bgt1HQQm.mjs";
import { n as prepareSessionEntryReplacementPublication } from "../../session-accessor.sqlite-replacement-state-0OnJKCvn.mjs";
import { i as transferSessionEntryWorkerCandidate } from "../../session-entry-patch.worker-D77IuVN7.mjs";
import { t as assertSessionSubagentRunsCurrent } from "../../session-accessor.sqlite-descendant-basis-Cg92YNGu.mjs";
import { t as commitPreparedSessionEntryLifecycleMutationInDatabase } from "../../session-accessor.sqlite-projection-state-B7YwcS58.mjs";
//#region src/config/sessions/session-lifecycle-projection.worker.ts
function commitSessionLifecycleProjection(input, { writeTransaction, admit, options }) {
	return writeTransaction("session.lifecycle.project", "Session lifecycle", (database) => {
		assertSessionSubagentRunsCurrent(input, options.env ?? process.env);
		const progressCardResetKeys = [];
		const projectionReconcileSessionIds = [];
		const result = commitPreparedSessionEntryLifecycleMutationInDatabase(database, input, input.removalPlans, {
			resetScope: {
				agentId: input.agentId,
				path: database.path,
				env: options.env
			},
			onResetBoundary: ({ sessionKey, sessionId, progressCardReset, projectionNeedsReconcile }) => {
				if (progressCardReset) progressCardResetKeys.push(sessionKey);
				if (projectionNeedsReconcile) projectionReconcileSessionIds.push(sessionId);
			}
		});
		const candidate = {
			kind: "session-lifecycle-projection",
			result,
			progressCardResetKeys,
			projectionReconcileSessionIds,
			publication: prepareSessionEntryReplacementPublication({
				...collectLifecycleIdentityChanges(input.projected, result.removedSessionKeys),
				pendingArchiveRecovery: result.pendingArchives,
				membershipInvalidatedKeys: [...result.removedSessionKeys, ...input.projected.upsertedEntries.flatMap(({ sessionKey, entry, expectedEntry }) => entry.sessionId !== expectedEntry?.sessionId ? [sessionKey] : [])],
				maintenancePlans: result.maintenancePlans
			}, database)
		};
		const receipt = transferSessionEntryWorkerCandidate(database, admit, candidate);
		assertSessionSubagentRunsCurrent(input, options.env ?? process.env);
		return receipt;
	});
}
/** Private planning commands borrow the executor's admitted connection. */
function bindSqliteWorkerBackend(binding, context) {
	const database = getOpenClawAgentDatabaseIfOpen({
		agentId: binding.agentId,
		path: context.databasePath,
		env: getSqliteWorkerStateContext().environment
	});
	if (!database || database.db !== context.database || database.path !== context.databasePath) throw new Error("Session lifecycle planning lost its canonical database owner");
	let closed = false;
	const assertOpen = () => {
		if (closed || !database.db.isOpen) throw new Error("Session lifecycle planning domain is closed");
		assertTransactionUsable(database.db);
	};
	return {
		execute(command) {
			assertOpen();
			return runSqliteDeferredTransactionSync(database.db, () => {
				if (command.type === "count") return readSessionEntryCount(database);
				if (command.type === "prepare") {
					const input = command.input;
					const store = readSessionEntryStore(database, { sessionKeys: [...input.removals.map((removal) => removal.exactStoredKey ? removal.sessionKey : removal.sessionKey.trim()), ...input.upsertSessionKeys] });
					const identity = readOpenClawAgentDatabaseIdentity(database).identity;
					return {
						store,
						selected: selectProjectedLifecycleRemovals(database, store, input.removals),
						archiveRecovery: typeof identity === "string" ? {
							pending: hasPendingSessionTranscriptArchives(database),
							databaseIdentity: identity
						} : void 0
					};
				}
				const input = command.input;
				return finishProjectedLifecycleRemovalPlans(database, input.archiveDirectory, input.store, input.selected, input.upsertedEntries);
			});
		},
		assertSettled() {
			assertOpen();
			if (database.db.isTransaction) throw new Error("Session lifecycle planning left a transaction open");
		},
		close() {
			closed = true;
		}
	};
}
//#endregion
export { bindSqliteWorkerBackend, commitSessionLifecycleProjection };