openclaw/dist/facade-runtime-BjmVS_9G.js

Multi-channel AI gateway with extensible messaging integrations

import { o as getPluginCacheRoot, s as getPluginCacheSource } from "./plugin-cache-DGWspMEc.js";
import { i as resolveBundledPluginsDir, t as areBundledPluginsDisabled } from "./bundled-dir-BEfbEeCF.js";
import { n as getCachedPluginSourceModuleLoader } from "./plugin-module-loader-cache-lf3kAaBw.js";
import { s as resolveLoaderPackageRoot } from "./sdk-alias-BMTmaiMP.js";
import { a as loadFacadeModuleAtLocationSync, c as resolveBundledMetadataManifestRecord, i as loadBundledPluginPublicSurfaceModuleSyncCore, o as createFacadeResolutionKey$1, s as resolveBundledFacadeModuleLocation } from "./facade-loader-CVT-xVW5.js";
import { createRequire } from "node:module";
import { fileURLToPath } from "node:url";
import path from "node:path";
//#region src/plugin-sdk/facade-runtime.ts
const OPENCLAW_PACKAGE_ROOT = resolveLoaderPackageRoot({
	modulePath: fileURLToPath(import.meta.url),
	moduleUrl: import.meta.url
}) ?? fileURLToPath(new URL("../..", import.meta.url));
const CURRENT_MODULE_PATH = fileURLToPath(import.meta.url);
const OPENCLAW_SOURCE_EXTENSIONS_ROOT = path.resolve(OPENCLAW_PACKAGE_ROOT, "extensions");
function createFacadeResolutionKey(params) {
	const bundledPluginsDir = resolveBundledPluginsDir(params.env ?? process.env);
	return createFacadeResolutionKey$1({
		...params,
		bundledPluginsDir,
		...params.env ? { env: params.env } : {}
	});
}
function resolveRegistryPluginModuleLocation(params) {
	return loadFacadeActivationCheckRuntime().resolveRegistryPluginModuleLocation(params);
}
function resolveFacadeModuleLocationUncached(params) {
	const env = params.env ?? process.env;
	if (!areBundledPluginsDisabled(env)) {
		const bundledPluginsDir = resolveBundledPluginsDir(env);
		const bundledLocation = resolveBundledFacadeModuleLocation({
			...params,
			currentModulePath: CURRENT_MODULE_PATH,
			packageRoot: OPENCLAW_PACKAGE_ROOT,
			bundledPluginsDir
		});
		if (bundledLocation) return bundledLocation;
	}
	return resolveRegistryPluginModuleLocation(params);
}
function resolveFacadeModuleLocation(params) {
	if (params.env !== void 0 && params.env !== process.env) return resolveFacadeModuleLocationUncached(params);
	const resolutionKey = `facade-registry:${createFacadeResolutionKey(params)}`;
	const artifacts = getPluginCacheRoot(OPENCLAW_PACKAGE_ROOT).artifacts;
	const cached = artifacts.get(resolutionKey);
	if (cached !== void 0) return cached;
	const location = resolveFacadeModuleLocationUncached(params);
	artifacts.set(resolutionKey, location);
	return location;
}
const nodeRequire = createRequire(import.meta.url);
const FACADE_ACTIVATION_CHECK_RUNTIME_CANDIDATES = ["./facade-activation-check.runtime.js", "./facade-activation-check.runtime.ts"];
function getFacadeActivationCheckRuntimeModule() {
	return getPluginCacheSource(CURRENT_MODULE_PATH).variants.get("activation-runtime")?.exports?.value;
}
function setFacadeActivationCheckRuntimeModule(module) {
	getPluginCacheSource(CURRENT_MODULE_PATH).variants.set("activation-runtime", { exports: { value: module } });
}
function getFacadeActivationCheckRuntimeSourceLoader(modulePath) {
	return getCachedPluginSourceModuleLoader({
		modulePath,
		importerUrl: import.meta.url,
		loaderFilename: import.meta.url
	});
}
function loadFacadeActivationCheckRuntimeFromCandidates(loadCandidate) {
	for (const candidate of FACADE_ACTIVATION_CHECK_RUNTIME_CANDIDATES) try {
		return loadCandidate(candidate);
	} catch {}
}
function throwFacadeActivationCheckRuntimeUnavailable() {
	throw new Error("Unable to load facade activation check runtime");
}
function loadFacadeActivationCheckRuntime() {
	let facadeActivationCheckRuntimeModule = getFacadeActivationCheckRuntimeModule();
	if (facadeActivationCheckRuntimeModule) return facadeActivationCheckRuntimeModule;
	facadeActivationCheckRuntimeModule = loadFacadeActivationCheckRuntimeFromCandidates((candidate) => nodeRequire(candidate));
	if (facadeActivationCheckRuntimeModule) {
		setFacadeActivationCheckRuntimeModule(facadeActivationCheckRuntimeModule);
		return facadeActivationCheckRuntimeModule;
	}
	facadeActivationCheckRuntimeModule = loadFacadeActivationCheckRuntimeFromCandidates((candidate) => getFacadeActivationCheckRuntimeSourceLoader(candidate)(candidate));
	if (facadeActivationCheckRuntimeModule) {
		setFacadeActivationCheckRuntimeModule(facadeActivationCheckRuntimeModule);
		return facadeActivationCheckRuntimeModule;
	}
	return throwFacadeActivationCheckRuntimeUnavailable();
}
async function loadFacadeActivationCheckRuntimeAsync() {
	const module = getFacadeActivationCheckRuntimeModule() ?? await import("./facade-activation-check.runtime.js");
	setFacadeActivationCheckRuntimeModule(module);
	return module;
}
function buildFacadeActivationCheckParams(params, location = resolveFacadeModuleLocation(params)) {
	return {
		...params,
		location,
		sourceExtensionsRoot: OPENCLAW_SOURCE_EXTENSIONS_ROOT
	};
}
/** Load a bundled or registry-backed plugin public surface, tracking activation ownership. */
function loadBundledPluginPublicSurfaceModuleSync(params) {
	const location = resolveFacadeModuleLocation(params);
	const trackingParams = buildFacadeActivationCheckParams(params, location);
	const trackedPluginId = () => resolveBundledMetadataManifestRecord(trackingParams)?.id ?? loadFacadeActivationCheckRuntime().resolveTrackedFacadePluginId(trackingParams);
	if (!location) return loadBundledPluginPublicSurfaceModuleSyncCore({
		...params,
		trackedPluginId
	});
	return loadFacadeModuleAtLocationSync({
		location,
		trackedPluginId
	});
}
/** Load an activated plugin public surface or throw when activation policy blocks access. */
function loadActivatedBundledPluginPublicSurfaceModuleSync(params) {
	loadFacadeActivationCheckRuntime().resolveActivatedBundledPluginPublicSurfaceAccessOrThrow(buildFacadeActivationCheckParams(params));
	return loadBundledPluginPublicSurfaceModuleSync(params);
}
/** Load activation asynchronously; allowed public artifacts still use the synchronous loader. */
async function loadActivatedBundledPluginPublicSurfaceModule(params) {
	(await loadFacadeActivationCheckRuntimeAsync().catch(throwFacadeActivationCheckRuntimeUnavailable)).resolveActivatedBundledPluginPublicSurfaceAccessOrThrow(buildFacadeActivationCheckParams(params));
	return loadBundledPluginPublicSurfaceModuleSync(params);
}
/** Load an activated plugin public surface, returning null when activation policy blocks access. */
function tryLoadActivatedBundledPluginPublicSurfaceModuleSync(params) {
	if (!loadFacadeActivationCheckRuntime().resolveBundledPluginPublicSurfaceAccess(buildFacadeActivationCheckParams(params)).allowed) return null;
	return loadBundledPluginPublicSurfaceModuleSync(params);
}
/** Async variant of tryLoadActivatedBundledPluginPublicSurfaceModuleSync for async call sites. */
async function tryLoadActivatedBundledPluginPublicSurfaceModule(params) {
	if (!(await loadFacadeActivationCheckRuntimeAsync()).resolveBundledPluginPublicSurfaceAccess(buildFacadeActivationCheckParams(params)).allowed) return null;
	return loadBundledPluginPublicSurfaceModuleSync(params);
}
//#endregion
export { tryLoadActivatedBundledPluginPublicSurfaceModuleSync as a, tryLoadActivatedBundledPluginPublicSurfaceModule as i, loadActivatedBundledPluginPublicSurfaceModuleSync as n, loadBundledPluginPublicSurfaceModuleSync as r, loadActivatedBundledPluginPublicSurfaceModule as t };