import fs from "node:fs";

import path from "node:path";

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

import type { PluginInstallRecord } from "../config/types.plugins.js";

import { isBlockedObjectKey } from "../infra/prototype-keys.js";

import {

normalizeOptionalLowercaseString,

candidate: PluginCandidate;

config?: OpenClawConfig;

env: NodeJS.ProcessEnv;

installRecords: Record<string, PluginInstallRecord>;

}): boolean {

if (params.candidate.origin !== "global") {

return false;

}

const record = loadInstalledPluginIndexInstallRecordsSync({ env: params.env })[params.pluginId];

const record = params.installRecords[params.pluginId];

if (!record) {

return false;

}

candidate: PluginCandidate;

config?: OpenClawConfig;

env: NodeJS.ProcessEnv;

installRecords: Record<string, PluginInstallRecord>;

}): number {

if (params.candidate.origin === "config") {

return 0;

candidate: params.candidate,

config: params.config,

env: params.env,

installRecords: params.installRecords,

})

) {

return 1;

env?: NodeJS.ProcessEnv;

candidates?: PluginCandidate[];

diagnostics?: PluginDiagnostic[];

installRecords?: Record<string, PluginInstallRecord>;

} = {},

): PluginManifestRegistry {

const config = params.config ?? {};

const normalized = normalizePluginsConfigWithResolver(config.plugins);

const env = params.env ?? process.env;

const cacheKey = buildCacheKey({ workspaceDir: params.workspaceDir, plugins: normalized, env });

const cacheEnabled = params.cache !== false && shouldUseManifestCache(env);

const cacheEnabled =

params.cache !== false && !params.installRecords && shouldUseManifestCache(env);

if (cacheEnabled) {

const cached = registryCache.get(cacheKey);

if (cached && cached.expiresAt > Date.now()) {

const seenIds = new Map<string, SeenIdEntry>();

const realpathCache = new Map<string, string>();

const currentHostVersion = resolveCompatibilityHostVersion(env);

let installRecords = params.installRecords;

let installRecordsLoaded = Boolean(params.installRecords);

const getInstallRecords = (): Record<string, PluginInstallRecord> => {

if (!installRecordsLoaded) {

installRecords = loadInstalledPluginIndexInstallRecordsSync({ env });

installRecordsLoaded = true;

}

return installRecords ?? {};

};

for (const candidate of candidates) {

const rejectHardlinks = candidate.origin !== "bundled";

candidate,

config,

env,

installRecords: getInstallRecords(),

});

const existingRank = resolveDuplicatePrecedenceRank({

pluginId: manifest.id,

candidate: existing.candidate,

config,

env,

installRecords: getInstallRecords(),

});

const candidateWins = candidateRank < existingRank;

const winnerCandidate = candidateWins ? candidate : existing.candidate;