openclaw/dist/plugin-state-worker-client-DfEvzPTa.mjs

Multi-channel AI gateway with extensible messaging integrations

import { c as resolveOpenClawStateSqlitePath } from "./openclaw-state-db.paths-CmKkMYdo.mjs";
import { n as ok, t as err } from "./result-BQGgYouL.mjs";
import { r as captureOpenClawStateWorkerContext } from "./openclaw-state-worker-context-BvvgY6-t.mjs";
import { C as withPluginStatePublication } from "./plugin-state-store.kernel-tvf2UnQN.mjs";
import { r as wrapPluginStateError } from "./plugin-state-store.database-9LaEAhMM.mjs";
import { t as assertSessionEntriesCurrentAdmission } from "./session-entry-current-admission-D6fbI5HG.mjs";
import { n as pluginStateWorkerOperations } from "./plugin-state-worker-contract-DvV7sf3-.mjs";
import { n as restorePluginStateWorkerFailure } from "./plugin-state-worker-errors-OfK4A0I5.mjs";
//#region src/plugin-state/plugin-state-worker-client.ts
async function execute({ env, assertActive, sessionEntryCurrent, context: capturedContext, signal }, command, missing, checks = {}) {
	const { assertCurrent, isObservation, existingOnly } = checks;
	const currentEntries = sessionEntryCurrent && "source" in sessionEntryCurrent ? {
		sources: [sessionEntryCurrent.source],
		assertCurrent: ([entry]) => sessionEntryCurrent.assertCurrent(entry)
	} : sessionEntryCurrent;
	const assertAdmission = assertCurrent ? () => {
		assertActive?.();
		assertCurrent();
	} : assertActive;
	assertAdmission?.();
	const databasePath = capturedContext?.admission.databasePath ?? resolveOpenClawStateSqlitePath(env ?? process.env);
	const description = pluginStateWorkerOperations[command.type];
	let dispatched = false;
	try {
		const context = capturedContext ?? captureOpenClawStateWorkerContext({
			path: databasePath,
			env
		});
		const [{ runOpenClawStateWorkerOperation }, { createSqliteWorkerWriteAdmission }, { createSqliteWorkerOperationAdmission }] = await Promise.all([
			import("./openclaw-state-worker-store-x5r3Lkjl.mjs"),
			import("./sqlite-worker-store-BTJspozr.mjs"),
			import("./sqlite-worker-operation-admission-CdS8iJYI.mjs")
		]);
		const operation = async (scope) => {
			dispatched = true;
			const result = await scope.execute(command.input === void 0 ? command : {
				type: command.type,
				input: {
					...command.input,
					sessionEntryCurrentSources: currentEntries?.sources
				}
			});
			if (!result.ok) throw restorePluginStateWorkerFailure(result.error);
			return result.value;
		};
		if (missing) {
			const result = await runOpenClawStateWorkerOperation(context, operation, {
				signal,
				existingOnly: true,
				assertCurrent: assertAdmission
			});
			assertActive?.();
			return result === void 0 ? missing() : result;
		}
		const assertWriteCurrent = (request) => {
			context.admission.assertCurrent();
			assertAdmission?.();
			assertSessionEntriesCurrentAdmission(request, currentEntries);
		};
		const createAdmission = command.type === "pluginState.replaceEntry" ? () => {
			const stages = [
				"transaction",
				"commit",
				"transaction",
				"commit"
			];
			let next = 0;
			return {
				nativeLocations: [databasePath],
				admission: createSqliteWorkerOperationAdmission((request, grant) => {
					if (request.stage !== stages[next]) throw new Error("Plugin state replacement authority requested out of order");
					assertWriteCurrent(request);
					if (!grant()) throw new Error("Plugin state replacement authority expired");
					next += 1;
				})
			};
		} : createSqliteWorkerWriteAdmission(assertWriteCurrent, [databasePath]);
		const result = await runOpenClawStateWorkerOperation(context, operation, {
			signal,
			assertCurrent: assertAdmission,
			createAdmission: withPluginStatePublication(createAdmission, context),
			existingOnly: existingOnly !== void 0
		});
		if (result === void 0 && existingOnly) return existingOnly.missing();
		if (isObservation?.(result)) assertAdmission?.();
		return result;
	} catch (error) {
		throw wrapPluginStateError(error, description.operation, dispatched ? description.code : "PLUGIN_STATE_OPEN_FAILED", dispatched ? description.message : "Failed to open the plugin state database.", databasePath);
	}
}
function createOperation(type, missing, isObservation) {
	return (params) => {
		const input = { ...params };
		const { env, assertActive, assertCurrent, sessionEntryCurrent, context, signal } = input;
		delete input.context;
		delete input.env;
		delete input.assertActive;
		delete input.assertCurrent;
		delete input.sessionEntryCurrent;
		delete input.signal;
		return execute({
			env,
			assertActive,
			sessionEntryCurrent,
			context,
			signal
		}, {
			type,
			input
		}, missing, {
			assertCurrent,
			isObservation
		});
	};
}
const registerPluginStateInWorker = createOperation("pluginState.register");
const replacePluginStateInWorker = createOperation("pluginState.replace");
const replacePluginStateEntryInWorker = createOperation("pluginState.replaceEntry");
const observePluginStateInWorker = createOperation("pluginState.observe", void 0, () => true);
const comparePluginStateUpdateInWorker = createOperation("pluginState.compareUpdate", void 0, (result) => result.status === "conflict");
const comparePluginStateDeleteInWorker = createOperation("pluginState.compareDelete", void 0, (result) => result.status === "conflict");
const registerPluginStateIfAbsentInWorker = createOperation("pluginState.registerIfAbsent");
const deletePluginStateIfEqualInWorker = createOperation("pluginState.deleteIfEqual");
const lookupPluginStateInWorker = createOperation("pluginState.lookup", () => void 0);
async function lookupManyPluginStateInWorker(params) {
	const { env, assertActive, sessionEntryCurrent, context, signal, ...input } = params;
	params.assertActive?.();
	if (input.keys.length === 0) return [];
	return (await execute({
		env,
		assertActive,
		sessionEntryCurrent,
		context,
		signal
	}, {
		type: "pluginState.lookupMany",
		input
	}, () => input.keys.map(() => ok(void 0)))).map((result) => result.ok ? result : err(restorePluginStateWorkerFailure(result.error)));
}
const consumePluginStateInWorker = createOperation("pluginState.consume");
const deletePluginStateInWorker = createOperation("pluginState.delete");
const listPluginStateInWorker = createOperation("pluginState.entries", () => []);
const clearPluginStateInWorker = createOperation("pluginState.clear");
function clearRuntimeHealthInWorker(params) {
	const { env, assertActive, assertCurrent, sessionEntryCurrent, context, signal, ...input } = params;
	return execute({
		env,
		assertActive,
		sessionEntryCurrent,
		context,
		signal
	}, {
		type: "pluginState.clearRuntimeHealth",
		input
	}, void 0, {
		assertCurrent,
		existingOnly: { missing: () => void 0 }
	});
}
function sweepExpiredPluginStateEntriesInWorker(params = {}) {
	return execute(params, {
		type: "pluginState.sweep",
		input: void 0
	});
}
const countPluginStateInWorker = createOperation("pluginState.count", () => 0);
const registerPluginStateJournalInWorker = createOperation("pluginState.appendJournal");
const listPluginStateInKeyRangeInWorker = createOperation("pluginState.entriesInKeyRange", () => []);
const movePluginStateEntriesInWorker = createOperation("pluginState.moveEntries");
//#endregion
export { registerPluginStateJournalInWorker as _, consumePluginStateInWorker as a, sweepExpiredPluginStateEntriesInWorker as b, deletePluginStateInWorker as c, lookupManyPluginStateInWorker as d, lookupPluginStateInWorker as f, registerPluginStateInWorker as g, registerPluginStateIfAbsentInWorker as h, comparePluginStateUpdateInWorker as i, listPluginStateInKeyRangeInWorker as l, observePluginStateInWorker as m, clearRuntimeHealthInWorker as n, countPluginStateInWorker as o, movePluginStateEntriesInWorker as p, comparePluginStateDeleteInWorker as r, deletePluginStateIfEqualInWorker as s, clearPluginStateInWorker as t, listPluginStateInWorker as u, replacePluginStateEntryInWorker as v, replacePluginStateInWorker as y };