return detail.package?.latestVersion ?? detail.package?.tags?.latest ?? null;

}

/** Detects package or skill detail payloads that represent skill-family packages. */

export function isClawHubFamilySkill(detail: ClawHubPackageDetail | ClawHubSkillDetail): boolean {

if ("package" in detail) {

return detail.package?.family === "skill";

}

return Boolean(detail.skill);

}

/** Checks whether a host plugin API version satisfies a ClawHub plugin API range. */

export function satisfiesPluginApiRange(

pluginApiVersion: string,

return result;

}

export async function preflightPluginPackageInstallSource(

params: {

packageDir: string;

} & PackageInstallCommonParams,

): Promise<PluginInstallFailureResult | null> {

const runtime = await loadPluginInstallRuntime();

const { logger } = runtime.resolveTimedInstallModeOptions(params, defaultLogger);

const validated = await validatePackagePluginInstallSource({

runtime,

packageDir: params.packageDir,

expectedPluginId: params.expectedPluginId,

requirePluginManifest: params.requirePluginManifest,

allowSourceTypeScriptEntries: params.allowSourceTypeScriptEntries,

dangerouslyForceUnsafeInstall: params.dangerouslyForceUnsafeInstall,

trustedSourceLinkedOfficialInstall: params.trustedSourceLinkedOfficialInstall,

config: params.config,

installPolicyRequest: params.installPolicyRequest,

logger,

mode: params.mode ?? "install",

});

return validated.ok ? null : validated;

}

async function installPluginFromPackageDir(

params: {

export function clearMemoryEmbeddingProviders(): void {

getMemoryEmbeddingProviders().clear();

}

export const resetMemoryEmbeddingProviders = clearMemoryEmbeddingProviders;

return value.filter((line): line is string => typeof line === "string");

}

export function getMemoryPromptSectionBuilder(): MemoryPromptSectionBuilder | undefined {

return memoryPluginState.capability?.capability.promptBuilder;

}

export function listMemoryPromptSupplements(): MemoryPromptSupplementRegistration[] {

return [...memoryPluginState.promptSupplements];

}

return memoryPluginState.capability?.capability.flushPlanResolver?.(params) ?? null;

}

export function getMemoryFlushPlanResolver(): MemoryFlushPlanResolver | undefined {

return memoryPluginState.capability?.capability.flushPlanResolver;

}

/** @deprecated Use registerMemoryCapability(pluginId, { runtime }) instead. */

export function registerMemoryRuntime(runtime: MemoryPluginRuntime): void {

registerMemoryRuntimeForPlugin(LEGACY_MEMORY_COMPAT_PLUGIN_ID, runtime);

};

}

export function resetPluginModuleLoaderStatsForTest(): void {

pluginModuleLoaderStats.calls = 0;

pluginModuleLoaderStats.nativeHits = 0;

pluginModuleLoaderStats.nativeMisses = 0;

pluginModuleLoaderStats.sourceTransformForced = 0;

pluginModuleLoaderStats.sourceTransformFallbacks = 0;

pluginModuleLoaderStats.sourceTransformTargets.clear();

}

function loadCreateJitiLoaderFactory(): PluginModuleLoaderFactory {

if (createJitiLoaderFactory) {

return createJitiLoaderFactory;

import path from "node:path";

import { isRecord as isJsonObject } from "@openclaw/normalization-core/record-coerce";

import { listAgentIds, resolveAgentDir } from "../agents/agent-scope.js";

import { resolveAuthProfileDatabasePath } from "../agents/auth-profiles/sqlite.js";

import type { OpenClawConfig } from "../config/types.openclaw.js";

import { formatErrorMessage } from "../infra/errors.js";

import { resolveUserPath } from "../utils.js";

return parseEnvValue(raw);

}

/** Lists canonical auth-profile stores visible to secrets audit/apply storage scanners. */

export function listAuthProfileStorePaths(config: OpenClawConfig, stateDir: string): string[] {

return listAuthProfileStoreAgentDirs(config, stateDir).map((agentDir) =>

resolveAuthProfileDatabasePath(agentDir),

);

}

/** Lists agent directories that own canonical auth-profile stores. */

export function listAuthProfileStoreAgentDirs(config: OpenClawConfig, stateDir: string): string[] {

return listAuthProfileStoreAgentDirsFromAuthStorePaths(config, stateDir);