import { execFileSync } from "node:child_process";

import { execFile } from "node:child_process";

import { copyFileSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync } from "node:fs";

import { tmpdir } from "node:os";

import { dirname, join, relative, resolve, sep } from "node:path";

import { promisify } from "node:util";

import { afterEach, describe, expect, it } from "vitest";

import { isScannable, scanDirectoryWithSummary } from "../security/skill-scanner.js";

packageName: string;

};

const execFileAsync = promisify(execFile);

const PACKAGE_SCAN_CONCURRENCY = 6;

const REQUIRED_REVIEWED_PUBLISHABLE_CRITICAL_FINDINGS = new Set([

"@openclaw/acpx:dangerous-exec:src/codex-auth-bridge.ts",

"@openclaw/acpx:dangerous-exec:src/runtime-internals/mcp-proxy.mjs",

.toSorted();

}

function collectNpmPackedFiles(packageDir: string, packageName: string): string[] {

const raw = execFileSync("npm", ["pack", "--dry-run", "--json", "--ignore-scripts"], {

cwd: packageDir,

encoding: "utf8",

maxBuffer: 128 * 1024 * 1024,

stdio: ["ignore", "pipe", "pipe"],

});

return parseNpmPackFiles(raw, packageName);

async function collectNpmPackedFiles(packageDir: string, packageName: string): Promise<string[]> {

const { stdout } = await execFileAsync(

"npm",

["pack", "--dry-run", "--json", "--ignore-scripts"],

{

cwd: packageDir,

encoding: "utf8",

maxBuffer: 128 * 1024 * 1024,

},

);

return parseNpmPackFiles(stdout, packageName);

}

function isScannerWalkedPackedPath(packedPath: string): boolean {

.toSorted((left, right) => left.packageName.localeCompare(right.packageName));

}

async function mapWithConcurrency<T, U>(

items: readonly T[],

concurrency: number,

fn: (item: T) => Promise<U>,

): Promise<U[]> {

const results = new Array<U>(items.length);

let nextIndex = 0;

const workerCount = Math.min(concurrency, items.length);

await Promise.all(

Array.from({ length: workerCount }, async () => {

while (nextIndex < items.length) {

const index = nextIndex;

nextIndex += 1;

results[index] = await fn(items[index]!);

}

}),

);

return results;

}

async function scanPublishablePluginPackage(plugin: PublishablePluginPackage): Promise<{

reviewedCriticalFindings: string[];

expectedReviewedCriticalFindings: string[];

unexpectedCriticalFindings: string[];

}> {

const reviewedCriticalFindings: string[] = [];

const expectedReviewedCriticalFindings: string[] = [];

const unexpectedCriticalFindings: string[] = [];

const packedFiles = await collectNpmPackedFiles(plugin.packageDir, plugin.packageName);

for (const packedFile of packedFiles) {

const key = `${plugin.packageName}:dangerous-exec:${normalizePackedFindingPath(packedFile)}`;

if (OPTIONAL_REVIEWED_PUBLISHABLE_DIST_CRITICAL_FINDINGS.has(key)) {

expectedReviewedCriticalFindings.push(key);

}

}

const stageDir = stageScannerRelevantPackedFiles(plugin.packageDir, packedFiles);

const summary = await scanDirectoryWithSummary(stageDir, {

excludeTestFiles: true,

maxFiles: 10_000,

});

for (const finding of summary.findings) {

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

continue;

}

const packedPath = normalizePackedFindingPath(

relative(stageDir, finding.file).split(sep).join("/"),

);

const key = `${plugin.packageName}:${finding.ruleId}:${packedPath}`;

if (

REQUIRED_REVIEWED_PUBLISHABLE_CRITICAL_FINDINGS.has(key) ||

OPTIONAL_REVIEWED_PUBLISHABLE_DIST_CRITICAL_FINDINGS.has(key)

) {

reviewedCriticalFindings.push(key);

continue;

}

unexpectedCriticalFindings.push([key, `${finding.line}`, finding.evidence].join(":"));

}

return {

reviewedCriticalFindings,

expectedReviewedCriticalFindings,

unexpectedCriticalFindings,

};

}

describe("publishable plugin npm package install security scan", () => {

it("keeps npm-published plugin files clear of unexpected critical hits", async () => {

const unexpectedCriticalFindings: string[] = [];

REQUIRED_REVIEWED_PUBLISHABLE_CRITICAL_FINDINGS,

);

for (const plugin of collectPublishablePluginPackages()) {

const packedFiles = collectNpmPackedFiles(plugin.packageDir, plugin.packageName);

for (const packedFile of packedFiles) {

const key = `${plugin.packageName}:dangerous-exec:${normalizePackedFindingPath(packedFile)}`;

if (OPTIONAL_REVIEWED_PUBLISHABLE_DIST_CRITICAL_FINDINGS.has(key)) {

expectedReviewedCriticalFindings.add(key);

}

const packageResults = await mapWithConcurrency(

collectPublishablePluginPackages(),

PACKAGE_SCAN_CONCURRENCY,

scanPublishablePluginPackage,

);

for (const result of packageResults) {

for (const key of result.expectedReviewedCriticalFindings) {

expectedReviewedCriticalFindings.add(key);

}

const stageDir = stageScannerRelevantPackedFiles(plugin.packageDir, packedFiles);

const summary = await scanDirectoryWithSummary(stageDir, {

excludeTestFiles: true,

maxFiles: 10_000,

});

for (const finding of summary.findings) {

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

continue;

}

const packedPath = normalizePackedFindingPath(

relative(stageDir, finding.file).split(sep).join("/"),

);

const key = `${plugin.packageName}:${finding.ruleId}:${packedPath}`;

if (expectedReviewedCriticalFindings.has(key)) {

reviewedCriticalFindings.add(key);

continue;

}

unexpectedCriticalFindings.push([key, `${finding.line}`, finding.evidence].join(":"));

for (const key of result.reviewedCriticalFindings) {

reviewedCriticalFindings.add(key);

}

unexpectedCriticalFindings.push(...result.unexpectedCriticalFindings);

}

expect(unexpectedCriticalFindings).toEqual([]);

expect(unexpectedCriticalFindings.toSorted()).toEqual([]);

expect([...reviewedCriticalFindings].toSorted()).toEqual(

[...expectedReviewedCriticalFindings].toSorted(),

);