closeSync,

existsSync,

lstatSync,

opendirSync,

openSync,

readdirSync,

readFileSync,

const DISABLE_POSTINSTALL_ENV = "OPENCLAW_DISABLE_BUNDLED_PLUGIN_POSTINSTALL";

const DISABLE_PLUGIN_REGISTRY_MIGRATION_ENV = "OPENCLAW_DISABLE_PLUGIN_REGISTRY_MIGRATION";

const DIST_INVENTORY_PATH = "dist/postinstall-inventory.json";

export const MAX_INSTALLED_DIST_SCAN_ENTRIES = 25_000;

const LEGACY_PLUGIN_RUNTIME_DEPS_DIR = "plugin-runtime-deps";

const BAILEYS_MEDIA_FILE = join("node_modules", "baileys", "lib", "Utils", "messages-media.js");

const BAILEYS_MEDIA_HOTFIX_NEEDLE = [

/async\s+function\s+encryptedStream|encryptedStream\s*=\s*async/u;

const NODE_COMPILE_CACHE_VERSION_DIR_RE = /^v\d+\.\d+\.\d+-/u;

class InstalledDistScanLimitError extends Error {}

function hasEnvFlag(env, key) {

const value = env?.[key]?.trim().toLowerCase();

return Boolean(value && value !== "0" && value !== "false" && value !== "no");

return candidatePath;

}

function createInstalledDistScanBudget(params = {}) {

return {

entries: 0,

limit: params.maxDistScanEntries ?? MAX_INSTALLED_DIST_SCAN_ENTRIES,

};

}

function resolveInstalledDistScanBudget(params = {}) {

return params.distScanBudget ?? createInstalledDistScanBudget(params);

}

function countInstalledDistScanEntry(budget) {

budget.entries += 1;

if (budget.entries > budget.limit) {

throw new InstalledDistScanLimitError(

`installed dist scan exceeded ${budget.limit} filesystem entries; refusing to scan unbounded package contents`,

);

}

}

function* iterateInstalledDistEntries(currentDir, params = {}) {

if (params.readdirSync) {

yield* params.readdirSync(currentDir, { withFileTypes: true });

return;

}

const dir = opendirSync(currentDir);

try {

while (true) {

const entry = dir.readSync();

if (!entry) {

break;

}

yield entry;

}

} finally {

dir.closeSync();

}

}

function* iterateOptionalInstalledDistEntries(currentDir, params = {}) {

try {

yield* iterateInstalledDistEntries(currentDir, params);

} catch (error) {

if (error instanceof InstalledDistScanLimitError) {

throw error;

}

}

}

function listInstalledDistFiles(params = {}) {

const readDir = params.readdirSync ?? readdirSync;

const distRoot = resolveInstalledDistRoot(params);

if (distRoot === null) {

return [];

}

const packageRoot = params.packageRoot ?? DEFAULT_PACKAGE_ROOT;

const pending = [distRoot.distDir];

const files = [];

const budget = resolveInstalledDistScanBudget(params);

while (pending.length > 0) {

const currentDir = pending.pop();

if (!currentDir) {

continue;

}

for (const entry of readDir(currentDir, { withFileTypes: true })) {

for (const entry of iterateInstalledDistEntries(currentDir, params)) {

countInstalledDistScanEntry(budget);

const entryPath = join(currentDir, entry.name);

if (entry.isSymbolicLink()) {

throw new Error(

}

function pruneEmptyDistDirectories(params = {}) {

const readDir = params.readdirSync ?? readdirSync;

const removeDirectory = params.rmdirSync ?? rmdirSync;

const distRoot = resolveInstalledDistRoot(params);

if (distRoot === null) {

return;

}

const packageRoot = params.packageRoot ?? DEFAULT_PACKAGE_ROOT;

const pathLstat = params.lstatSync ?? lstatSync;

const budget = resolveInstalledDistScanBudget(params);

function isDirectoryEmpty(currentDir) {

for (const entry of iterateInstalledDistEntries(currentDir, params)) {

void entry;

countInstalledDistScanEntry(budget);

return false;

}

return true;

}

function prune(currentDir) {

for (const entry of readDir(currentDir, { withFileTypes: true })) {

const childDirs = [];

for (const entry of iterateInstalledDistEntries(currentDir, params)) {

countInstalledDistScanEntry(budget);

if (entry.isSymbolicLink()) {

throw new Error(

`unsafe dist entry: ${normalizeRelativePath(relative(packageRoot, join(currentDir, entry.name)))}`,

if (!entry.isDirectory()) {

continue;

}

prune(join(currentDir, entry.name));

childDirs.push(join(currentDir, entry.name));

}

for (const childDir of childDirs) {

prune(childDir);

}

if (currentDir === distRoot.distDir) {

return;

`unsafe dist directory: ${normalizeRelativePath(relative(packageRoot, currentDir))}`,

);

}

if (readDir(currentDir).length === 0) {

if (isDirectoryEmpty(currentDir)) {

removeDirectory(

assertSafeInstalledDistPath(normalizeRelativePath(relative(packageRoot, currentDir)), {

packageRoot,

}

function pruneLegacyInstalledPluginDependencyDirs(params) {

const readDir = params.readdirSync ?? readdirSync;

const removePath = params.rmSync ?? rmSync;

const packageRoot = params.packageRoot ?? DEFAULT_PACKAGE_ROOT;

const extensionsDir = join(packageRoot, "dist", "extensions");

const budget = resolveInstalledDistScanBudget(params);

const removed = [];

let pluginEntries;

try {

pluginEntries = readDir(extensionsDir, { withFileTypes: true });

} catch {

return removed;

}

for (const pluginEntry of pluginEntries) {

for (const pluginEntry of iterateOptionalInstalledDistEntries(extensionsDir, params)) {

countInstalledDistScanEntry(budget);

if (!pluginEntry.isDirectory() || pluginEntry.isSymbolicLink()) {

continue;

}

const pluginDir = join(extensionsDir, pluginEntry.name);

let pluginChildren;

try {

pluginChildren = readDir(pluginDir, { withFileTypes: true });

} catch {

continue;

}

for (const childEntry of pluginChildren) {

const dependencyDirNames = [];

for (const childEntry of iterateOptionalInstalledDistEntries(pluginDir, params)) {

countInstalledDistScanEntry(budget);

if (!isLegacyInstalledPluginDependencyDirName(childEntry.name)) {

continue;

}

const safePluginDir = assertSafeInstalledDistPath(

normalizeRelativePath(relative(packageRoot, pluginDir)),

{

packageRoot,

distDirReal: params.distDirReal,

realpathSync: params.realpathSync,

},

);

dependencyDirNames.push(childEntry.name);

}

if (dependencyDirNames.length === 0) {

continue;

}

const safePluginDir = assertSafeInstalledDistPath(

normalizeRelativePath(relative(packageRoot, pluginDir)),

{

packageRoot,

distDirReal: params.distDirReal,

realpathSync: params.realpathSync,

},

);

for (const dependencyDirName of dependencyDirNames) {

const relativePath = normalizeRelativePath(

relative(packageRoot, join(pluginDir, childEntry.name)),

relative(packageRoot, join(pluginDir, dependencyDirName)),

);

removePath(join(safePluginDir, childEntry.name), { recursive: true, force: true });

removePath(join(safePluginDir, dependencyDirName), { recursive: true, force: true });

removed.push(relativePath);

}

}

if (distRoot === null) {

return [];

}

const distScanBudget = createInstalledDistScanBudget(params);

const distScanParams = { ...params, distScanBudget };

const removedLegacyDependencyDirs = pruneLegacyInstalledPluginDependencyDirs({

...distScanParams,

packageRoot,

distDirReal: distRoot.distDirReal,

realpathSync: params.realpathSync,

readdirSync: params.readdirSync,

rmSync: params.rmSync,

});

let expectedFiles = params.expectedFiles ?? null;

return [];

}

}

const installedFiles = listInstalledDistFiles(params);

const installedFiles = listInstalledDistFiles(distScanParams);

const readFile = params.readFileSync ?? readFileSync;

expectedFiles = new Set(

expandPackageDistImportClosure({

removed.push(relativePath);

}

pruneEmptyDistDirectories(params);

pruneEmptyDistDirectories(distScanParams);

if (removed.length > 0) {

log.log(`[postinstall] pruned stale dist files: ${removed.join(", ")}`);