openclaw/dist/entry-status-kSQWYkJm.js

Multi-channel AI gateway with extensible messaging integrations

import { c as normalizeOptionalString } from "./string-coerce-mnp54Vah.js";
//#region src/shared/entry-metadata.ts
/** Resolves entry emoji/homepage with metadata taking precedence over frontmatter aliases. */
function resolveEmojiAndHomepage(params) {
	const emoji = params.metadata?.emoji ?? params.frontmatter?.emoji;
	const homepage = normalizeOptionalString(params.metadata?.homepage ?? params.frontmatter?.homepage ?? params.frontmatter?.website ?? params.frontmatter?.url);
	return {
		...emoji ? { emoji } : {},
		...homepage ? { homepage } : {}
	};
}
//#endregion
//#region src/shared/requirements.ts
/** Returns required binaries absent from both the local host and optional remote target. */
function resolveMissingBins(params) {
	const remote = params.hasRemoteBin;
	return params.required.filter((bin) => {
		if (params.hasLocalBin(bin)) return false;
		if (remote?.(bin)) return false;
		return true;
	});
}
/** Treats an any-bin requirement as satisfied when any listed binary exists locally or remotely. */
function resolveMissingAnyBins(params) {
	if (params.required.length === 0) return [];
	if (params.required.some((bin) => params.hasLocalBin(bin))) return [];
	if (params.hasRemoteAnyBin?.(params.required)) return [];
	return params.required;
}
/** Resolves OS requirements against local and remote platforms, accepting macos as darwin. */
function resolveMissingOs(params) {
	if (params.required.length === 0) return [];
	const localPlatform = normalizeOsRequirementPlatform(params.localPlatform);
	const requiredPlatforms = new Set(params.required.map((platform) => normalizeOsRequirementPlatform(platform)));
	if (requiredPlatforms.has(localPlatform)) return [];
	if (params.remotePlatforms?.some((platform) => requiredPlatforms.has(normalizeOsRequirementPlatform(platform)))) return [];
	return params.required;
}
function normalizeOsRequirementPlatform(platform) {
	const normalized = platform.trim().toLowerCase();
	return normalized === "macos" ? "darwin" : normalized;
}
/** Returns environment variable names whose caller-provided satisfaction check fails. */
function resolveMissingEnv(params) {
	const missing = [];
	for (const envName of params.required) {
		if (params.isSatisfied(envName)) continue;
		missing.push(envName);
	}
	return missing;
}
/** Builds per-config-path status while preserving every declared path for UI diagnostics. */
function buildConfigChecks(params) {
	return params.required.map((pathStr) => {
		return {
			path: pathStr,
			satisfied: params.isSatisfied(pathStr)
		};
	});
}
/** Evaluates normalized requirements and returns missing categories plus config diagnostics. */
function evaluateRequirements(params) {
	const missingBins = resolveMissingBins({
		required: params.required.bins,
		hasLocalBin: params.hasLocalBin,
		hasRemoteBin: params.hasRemoteBin
	});
	const missingAnyBins = resolveMissingAnyBins({
		required: params.required.anyBins,
		hasLocalBin: params.hasLocalBin,
		hasRemoteAnyBin: params.hasRemoteAnyBin
	});
	const missingOs = resolveMissingOs({
		required: params.required.os,
		localPlatform: params.localPlatform,
		remotePlatforms: params.remotePlatforms
	});
	const missingEnv = resolveMissingEnv({
		required: params.required.env,
		isSatisfied: params.isEnvSatisfied
	});
	const configChecks = buildConfigChecks({
		required: params.required.config,
		isSatisfied: params.isConfigSatisfied
	});
	const missingConfig = configChecks.filter((check) => !check.satisfied).map((check) => check.path);
	const missing = params.always ? {
		bins: [],
		anyBins: [],
		env: [],
		config: [],
		os: []
	} : {
		bins: missingBins,
		anyBins: missingAnyBins,
		env: missingEnv,
		config: missingConfig,
		os: missingOs
	};
	return {
		missing,
		eligible: params.always || missing.bins.length === 0 && missing.anyBins.length === 0 && missing.env.length === 0 && missing.config.length === 0 && missing.os.length === 0,
		configChecks
	};
}
/** Converts entry metadata into the canonical requirement shape before evaluation. */
function evaluateRequirementsFromMetadata(params) {
	const required = {
		bins: params.metadata?.requires?.bins ?? [],
		anyBins: params.metadata?.requires?.anyBins ?? [],
		env: params.metadata?.requires?.env ?? [],
		config: params.metadata?.requires?.config ?? [],
		os: params.metadata?.os ?? []
	};
	return {
		required,
		...evaluateRequirements({
			always: params.always,
			required,
			hasLocalBin: params.hasLocalBin,
			hasRemoteBin: params.hasRemoteBin,
			hasRemoteAnyBin: params.hasRemoteAnyBin,
			localPlatform: params.localPlatform,
			remotePlatforms: params.remotePlatforms,
			isEnvSatisfied: params.isEnvSatisfied,
			isConfigSatisfied: params.isConfigSatisfied
		})
	};
}
/** Convenience wrapper for callers that receive remote capability checks as one object. */
function evaluateRequirementsFromMetadataWithRemote(params) {
	return evaluateRequirementsFromMetadata({
		always: params.always,
		metadata: params.metadata,
		hasLocalBin: params.hasLocalBin,
		hasRemoteBin: params.remote?.hasBin,
		hasRemoteAnyBin: params.remote?.hasAnyBin,
		localPlatform: params.localPlatform,
		remotePlatforms: params.remote?.platforms,
		isEnvSatisfied: params.isEnvSatisfied,
		isConfigSatisfied: params.isConfigSatisfied
	});
}
//#endregion
//#region src/shared/entry-status.ts
/** Resolves entry presentation metadata and requirement eligibility in one shared shape. */
function evaluateEntryMetadataRequirements(params) {
	const { emoji, homepage } = resolveEmojiAndHomepage({
		metadata: params.metadata,
		frontmatter: params.frontmatter
	});
	const { required, missing, eligible, configChecks } = evaluateRequirementsFromMetadataWithRemote({
		always: params.always,
		metadata: params.metadata ?? void 0,
		hasLocalBin: params.hasLocalBin,
		localPlatform: params.localPlatform,
		remote: params.remote,
		isEnvSatisfied: params.isEnvSatisfied,
		isConfigSatisfied: params.isConfigSatisfied
	});
	return {
		...emoji ? { emoji } : {},
		...homepage ? { homepage } : {},
		required,
		missing,
		requirementsSatisfied: eligible,
		configChecks
	};
}
/** Evaluates entry metadata requirements against the current Node platform. */
function evaluateEntryMetadataRequirementsForCurrentPlatform(params) {
	return evaluateEntryMetadataRequirements({
		...params,
		localPlatform: process.platform
	});
}
/** Evaluates an entry object's metadata/frontmatter requirements on the current platform. */
function evaluateEntryRequirementsForCurrentPlatform(params) {
	return evaluateEntryMetadataRequirementsForCurrentPlatform({
		always: params.always,
		metadata: params.entry.metadata,
		frontmatter: params.entry.frontmatter,
		hasLocalBin: params.hasLocalBin,
		remote: params.remote,
		isEnvSatisfied: params.isEnvSatisfied,
		isConfigSatisfied: params.isConfigSatisfied
	});
}
//#endregion
export { evaluateEntryRequirementsForCurrentPlatform as t };