setupEntry?: string;

};

const RUNTIME_GRAPH_SCAN_EXTENSIONS = [

".js",

".mjs",

".cjs",

".ts",

".mts",

".cts",

".jsx",

".tsx",

];

const RUNTIME_GRAPH_SCAN_MAX_FILES = 1000;

const LOCAL_RUNTIME_IMPORT_PATTERN =

/\b(?:import|export)\s+(?:[^"']*?\s+from\s*)?["']([^"']+)["']|\bimport\s*\(\s*["']([^"']+)["']\s*\)|\brequire\s*\(\s*["']([^"']+)["']\s*\)/g;

type PackageManifestTraversalLimits = {

maxDepth: number;

maxDirectories: number;

};

}

function rebuildBuiltinScanCounts(scan: BuiltinInstallScan): BuiltinInstallScan {

let critical = 0;

let warn = 0;

let info = 0;

for (const finding of scan.findings) {

if (finding.severity === "critical") {

critical += 1;

} else if (finding.severity === "warn") {

warn += 1;

} else {

info += 1;

}

}

return {

...scan,

critical,

warn,

info,

};

}

const DEFAULT_PACKAGE_MANIFEST_TRAVERSAL_LIMITS: PackageManifestTraversalLimits = {

maxDepth: 64,

maxDirectories: 10_000,

maxManifests: 10_000,

};

const DEFAULT_INSTALLED_PACKAGE_CODE_SCAN_MAX_FILES = 25_000;

function readPositiveIntegerEnv(name: string, fallback: number): number {

const rawValue = process.env[name];

};

}

function resolveInstalledPackageCodeScanMaxFiles(): number {

return readPositiveIntegerEnv(

"OPENCLAW_INSTALL_SCAN_MAX_CODE_FILES",

DEFAULT_INSTALLED_PACKAGE_CODE_SCAN_MAX_FILES,

);

}

function isSamePathOrInside(parentPath: string, candidatePath: string): boolean {

return parentPath === candidatePath || isPathInside(parentPath, candidatePath);

}

return selectedRoots.map((selectedRoot) => selectedRoot.packageDir);

}

function normalizeRelativeScanPath(relativePath: string): string {

return relativePath.split(path.sep).join("/");

}

function isKnownBenignLanceDbFinding(params: {

finding: InstallScanFinding;

packageDir: string;

}): boolean {

const relativePath = normalizeRelativeScanPath(

path.relative(params.packageDir, params.finding.file),

);

const evidence = params.finding.evidence ?? "";

if (params.finding.ruleId === "dangerous-exec" && relativePath === "dist/native.js") {

return (

evidence.includes("child_process") &&

/\bexecSync\(\s*['"](?:ldd --version|which ldd)['"]/.test(evidence)

);

}

if (

params.finding.ruleId === "dynamic-code-execution" &&

relativePath === "dist/embedding/transformers.js"

) {

return /\beval\(\s*['"]import\(["']@huggingface\/transformers["']\)['"]\s*\)/.test(evidence);

}

return false;

}

async function suppressKnownBenignInstalledDependencyFindings(params: {

builtinScan: BuiltinInstallScan;

packageDir: string;

}): Promise<BuiltinInstallScan> {

if (params.builtinScan.status !== "ok" || params.builtinScan.findings.length === 0) {

return params.builtinScan;

}

const manifest = await tryReadJson<PackageManifest>(path.join(params.packageDir, "package.json"));

if (manifest?.name !== "@lancedb/lancedb") {

return params.builtinScan;

}

const findings = params.builtinScan.findings.filter(

(finding) => !isKnownBenignLanceDbFinding({ finding, packageDir: params.packageDir }),

);

if (findings.length === params.builtinScan.findings.length) {

return params.builtinScan;

}

return rebuildBuiltinScanCounts({

...params.builtinScan,

findings,

});

}

async function collectPackageManifestPaths(params: {

allowManagedNpmRootPackagePeerSymlinks?: boolean;

rootDir: string;

includeFiles?: string[];

logger: InstallScanLogger;

maxFiles?: number;

onlyIncludeFiles?: boolean;

path: string;

suppressBuiltinWarnings?: boolean;

suspiciousMessage: string;

includeNodeModules: params.includeNodeModules,

includeFiles: params.includeFiles,

maxFiles: params.maxFiles,

onlyIncludeFiles: params.onlyIncludeFiles,

});

if (params.failOnTruncated && scanSummary.truncated) {

return buildBuiltinScanFromError(

return [...new Set(entries)];

}

async function resolveRuntimeGraphFileCandidate(filePath: string): Promise<string | undefined> {

const resolvedPath = path.resolve(filePath);

const ext = path.extname(resolvedPath).toLowerCase();

const candidates = ext

? [resolvedPath]

: [

resolvedPath,

...RUNTIME_GRAPH_SCAN_EXTENSIONS.map((runtimeExt) => `${resolvedPath}${runtimeExt}`),

...RUNTIME_GRAPH_SCAN_EXTENSIONS.map((runtimeExt) =>

path.join(resolvedPath, `index${runtimeExt}`),

),

];

for (const candidate of candidates) {

let stat: Awaited<ReturnType<typeof fs.stat>>;

try {

stat = await fs.stat(candidate);

} catch {

continue;

}

if (stat.isFile() && RUNTIME_GRAPH_SCAN_EXTENSIONS.includes(path.extname(candidate))) {

return candidate;

}

}

return undefined;

}

function collectLocalRuntimeImportSpecifiers(source: string): string[] {

const specifiers: string[] = [];

for (const match of source.matchAll(LOCAL_RUNTIME_IMPORT_PATTERN)) {

const specifier = match[1] ?? match[2] ?? match[3];

if (specifier?.startsWith(".")) {

specifiers.push(specifier);

}

}

return specifiers;

}

async function collectPackageRuntimeGraphScanEntries(params: {

entryFiles: string[];

packageDir: string;

}): Promise<string[]> {

const packageDir = path.resolve(params.packageDir);

const seen = new Set<string>();

const queue: string[] = [];

const out: string[] = [];

for (const entryFile of params.entryFiles) {

const resolvedEntry = await resolveRuntimeGraphFileCandidate(entryFile);

if (resolvedEntry && isPathInside(packageDir, resolvedEntry)) {

queue.push(resolvedEntry);

}

}

while (queue.length > 0 && out.length < RUNTIME_GRAPH_SCAN_MAX_FILES) {

const filePath = queue.shift();

if (!filePath) {

break;

}

const resolvedPath = path.resolve(filePath);

if (seen.has(resolvedPath) || !isPathInside(packageDir, resolvedPath)) {

continue;

}

seen.add(resolvedPath);

out.push(resolvedPath);

let source: string;

try {

source = await fs.readFile(resolvedPath, "utf-8");

} catch {

continue;

}

for (const specifier of collectLocalRuntimeImportSpecifiers(source)) {

const importedPath = path.resolve(path.dirname(resolvedPath), specifier);

if (!isPathInside(packageDir, importedPath)) {

continue;

}

const resolvedImport = await resolveRuntimeGraphFileCandidate(importedPath);

if (resolvedImport && !seen.has(path.resolve(resolvedImport))) {

queue.push(resolvedImport);

}

}

}

return out;

}

function buildBlockedScanResult(params: {

builtinScan: BuiltinInstallScan;

dangerouslyForceUnsafeInstall?: boolean;

return await scanDirectoryTarget({

includeFiles: [params.path],

logger: params.logger,

onlyIncludeFiles: true,

path: directory,

suspiciousMessage: params.suspiciousMessage,

targetName: params.targetName,

forcedScanEntries.push(resolvedEntry);

}

const runtimeGraphScanEntries = await collectPackageRuntimeGraphScanEntries({

entryFiles: forcedScanEntries,

packageDir: params.packageDir,

});

const builtinScan = await scanDirectoryTarget({

includeFiles: forcedScanEntries,

includeFiles: runtimeGraphScanEntries,

logger: params.logger,

onlyIncludeFiles: true,

path: params.packageDir,

suppressBuiltinWarnings: params.trustedSourceLinkedOfficialInstall === true,

suspiciousMessage: `Plugin "{target}" has {count} suspicious code pattern(s). Run "openclaw security audit --deep" for details.`,

dependencyScanRootDir: params.dependencyScanRootDir,

packageDir: params.packageDir,

});

const directoryScanRoots = await collectNonOverlappingPackageScanRoots(scanRoots);

for (const packageDir of directoryScanRoots) {

const manifestScanRoots = await collectNonOverlappingPackageScanRoots(scanRoots);

for (const packageDir of manifestScanRoots) {

const dependencyBlocked = await scanManifestDependencyDenylist({

logger: params.logger,

packageDir,

}

}

let remainingMaxFiles = resolveInstalledPackageCodeScanMaxFiles();

const pluginRootRealPath = await fs

.realpath(params.packageDir)

.catch(() => path.resolve(params.packageDir));

for (const packageDir of directoryScanRoots) {

if (remainingMaxFiles <= 0) {

return resolveBuiltinScanDecision({

builtinScan: buildBuiltinScanFromError(

"code safety scan reached file limit (configured limit)",

),

logger: params.logger,

dangerouslyForceUnsafeInstall: params.dangerouslyForceUnsafeInstall,

trustedSourceLinkedOfficialInstall: params.trustedSourceLinkedOfficialInstall,

targetLabel: `Plugin "${params.pluginId}" installation`,

});

}

const packageRealPath = await fs.realpath(packageDir).catch(() => path.resolve(packageDir));

const isPluginRoot = packageRealPath === pluginRootRealPath;

const installedTreeSuspiciousMessage = `Plugin "{target}" installed tree has {count} suspicious code pattern(s). Run "openclaw security audit --deep" for details.`;

const installedTreeWarningMessage = `WARNING: Plugin "${params.pluginId}" installed tree contains dangerous code patterns`;

const rawBuiltinScan = await scanDirectoryTarget({

deferBuiltinWarnings: true,

excludeTestFiles: isPluginRoot,

failOnTruncated: true,

includeHiddenDirectories: true,

includeNestedNodeModulesTestFiles: isPluginRoot,

includeNodeModules: true,

logger: params.logger,

maxFiles: remainingMaxFiles,

path: packageDir,

suppressBuiltinWarnings: params.trustedSourceLinkedOfficialInstall === true,

suspiciousMessage: installedTreeSuspiciousMessage,

targetName: params.pluginId,

warningMessage: installedTreeWarningMessage,

});

const builtinScan = await suppressKnownBenignInstalledDependencyFindings({

builtinScan: rawBuiltinScan,

packageDir,

});

if (params.trustedSourceLinkedOfficialInstall !== true && builtinScan.status === "ok") {

if (builtinScan.critical > 0) {

params.logger.warn?.(

`${installedTreeWarningMessage}: ${buildCriticalDetails({ findings: builtinScan.findings })}`,

);

} else if (builtinScan.warn > 0) {

params.logger.warn?.(

installedTreeSuspiciousMessage

.replace("{count}", String(builtinScan.warn))

.replace("{target}", params.pluginId),

);

}

}

const builtinBlocked = resolveBuiltinScanDecision({

builtinScan,

logger: params.logger,

dangerouslyForceUnsafeInstall: params.dangerouslyForceUnsafeInstall,

trustedSourceLinkedOfficialInstall: params.trustedSourceLinkedOfficialInstall,

targetLabel: `Plugin "${params.pluginId}" installation`,

});

if (builtinBlocked) {

return builtinBlocked;

}

remainingMaxFiles -= builtinScan.scannedFiles;

}

return undefined;

}