type PackageManifest,

type PluginPackageChannel,

} from "./manifest.js";

import { isPathInsideWithRealpath, safeRealpathSync } from "./path-safety.js";

import { isPathInside, safeRealpathSync } from "./path-safety.js";

import { tracePluginLifecyclePhase } from "./plugin-lifecycle-trace.js";

import {

normalizePluginDependencySpecs,

);

}

function resolvePackageJsonPath(record: InstalledPluginIndexRecord): string | undefined {

function resolvePackageJsonPath(

record: InstalledPluginIndexRecord,

realpathCache: Map<string, string>,

): string | undefined {

if (!record.packageJson?.path) {

return undefined;

}

const rootDir = resolveInstalledPluginRootDir(record);

const realRootDir = safeRealpathSync(rootDir) ?? path.resolve(rootDir);

const realRootDir = safeRealpathSync(rootDir, realpathCache) ?? path.resolve(rootDir);

const packageJsonPath = path.resolve(realRootDir, record.packageJson.path);

const relative = path.relative(realRootDir, packageJsonPath);

if (!isRelativePathInsideOrEqual(relative)) {

return undefined;

}

if (!isPathInsideWithRealpath(realRootDir, packageJsonPath)) {

const packageJsonRealPath = safeRealpathSync(packageJsonPath, realpathCache);

if (!packageJsonRealPath || !isPathInside(realRootDir, packageJsonRealPath)) {

return undefined;

}

return packageJsonPath;

}

function buildInstalledManifestRegistryIndexKey(index: InstalledPluginIndex) {

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

return {

version: index.version,

hostContractVersion: index.hostContractVersion,

installRecords: index.installRecords,

diagnostics: index.diagnostics,

plugins: index.plugins.map((record) => {

const packageJsonPath = resolvePackageJsonPath(record);

const packageJsonPath = resolvePackageJsonPath(record, realpathCache);

return {

pluginId: record.pluginId,

packageName: record.packageName,

return channel;

}

function resolveInstalledPackageMetadata(record: InstalledPluginIndexRecord): {

function resolveInstalledPackageMetadata(

record: InstalledPluginIndexRecord,

realpathCache: Map<string, string>,

): {

packageManifest?: OpenClawPackageManifest;

packageDependencies?: PluginDependencySpecMap;

packageOptionalDependencies?: PluginDependencySpecMap;

channel: recordPackageChannel,

}

: undefined;

const packageJsonPath = record.packageJson?.path ? resolvePackageJsonPath(record) : undefined;

const packageJsonPath = record.packageJson?.path

? resolvePackageJsonPath(record, realpathCache)

: undefined;

if (!packageJsonPath) {

return fallbackPackageManifest ? { packageManifest: fallbackPackageManifest } : {};

}

return fallbackPackageManifest ? { packageManifest: fallbackPackageManifest } : {};

}

function toPluginCandidate(record: InstalledPluginIndexRecord): PluginCandidate {

function toPluginCandidate(

record: InstalledPluginIndexRecord,

realpathCache: Map<string, string>,

): PluginCandidate {

const rootDir = resolveInstalledPluginRootDir(record);

const packageMetadata = resolveInstalledPackageMetadata(record);

const packageMetadata = resolveInstalledPackageMetadata(record, realpathCache);

return {

idHint: record.pluginId,

source: record.source ?? resolveFallbackPluginSource(record),

}

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

const pluginIdSet = params.pluginIds?.length ? new Set(params.pluginIds) : null;

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

const diagnostics = pluginIdSet

? params.index.diagnostics.filter((diagnostic) => {

const pluginId = diagnostic.pluginId;

const candidates = params.index.plugins

.filter((plugin) => params.includeDisabled || plugin.enabled)

.filter((plugin) => !pluginIdSet || pluginIdSet.has(plugin.pluginId))

.map(toPluginCandidate);

.map((plugin) => toPluginCandidate(plugin, realpathCache));

return loadPluginManifestRegistry({

config: params.config,

workspaceDir: params.workspaceDir,