scopes: ["operator.read", "operator.approvals"],

},

target: {

kind: "tool",

name: "browser",

owner: "browser-tools",

kind: "plugin",

name: "@acme/security-event-plugin",

owner: "plugin-installer",

},

policy: {

id: "tools.exec",

"openclaw.security.actor.id_hash": "agent-hash-1",

"openclaw.security.actor.role": "operator",

"openclaw.security.actor.scopes": "operator.read,operator.approvals",

"openclaw.security.target.kind": "tool",

"openclaw.security.target.name": "browser",

"openclaw.security.target.owner": "browser-tools",

"openclaw.security.target.kind": "plugin",

"openclaw.security.target.name": "@acme/security-event-plugin",

"openclaw.security.target.owner": "plugin-installer",

"openclaw.security.policy.id": "tools.exec",

"openclaw.security.policy.decision": "deny",

"openclaw.security.policy.reason": "allowlist.miss",

"openclaw.trace_id",

]);

const LOW_CARDINALITY_VALUE_RE = /^[A-Za-z0-9_.:-]{1,120}$/u;

const SECURITY_TARGET_NAME_VALUE_RE = /^[A-Za-z0-9@/_.:-]{1,256}$/u;

const MAX_OTEL_CONTENT_ATTRIBUTE_CHARS = 128 * 1024;

const MAX_OTEL_CONTENT_ARRAY_ITEMS = 200;

const MAX_OTEL_LOG_BODY_CHARS = 4 * 1024;

return LOW_CARDINALITY_VALUE_RE.test(redacted) ? redacted : fallback;

}

function securityTargetNameAttr(value: string | undefined, fallback = "unknown"): string {

if (!value) {

return fallback;

}

const redacted = redactSensitiveText(value.trim());

const redactedLower = redacted.toLowerCase();

if (redactedLower.startsWith("agent:") || redactedLower.includes(":agent:")) {

return fallback;

}

return SECURITY_TARGET_NAME_VALUE_RE.test(redacted) ? redacted : fallback;

}

function lowCardinalityQueueLaneAttr(value: string | undefined, fallback = "unknown"): string {

if (!value) {

return fallback;

assignOtelLogAttribute(

attributes,

"openclaw.security.target.name",

lowCardinalityAttr(evt.target.name),

securityTargetNameAttr(evt.target.name),

);

}

if (evt.target.owner) {

const npmDir = path.join(root, "npm");

const extensionsDir = path.join(root, "extensions");

const { scriptPath, logPath } = writeBlockingInstallPolicyScript(root);

mockNpmViewMetadata({ name: "@acme/policy-preflight-plugin" });

const packageName = "@acme/policy-preflight-plugin";

mockNpmViewMetadata({ name: packageName });

const captured = captureSecurityEvents();

const result = await installPluginFromNpmSpec({

spec: "@acme/policy-preflight-plugin@1.0.0",

extensionsDir,

npmDir,

config: configWithInstallPolicy(scriptPath, logPath),

});

let result: Awaited<ReturnType<typeof installPluginFromNpmSpec>>;

try {

result = await installPluginFromNpmSpec({

spec: `${packageName}@1.0.0`,

extensionsDir,

npmDir,

config: configWithInstallPolicy(scriptPath, logPath),

});

} finally {

captured.stop();

}

expect(result.ok).toBe(false);

if (!result.ok) {

expect(result.code, result.error).toBe(PLUGIN_INSTALL_ERROR_CODE.SECURITY_SCAN_BLOCKED);

expect(result.error).toContain("npm installs are disabled by policy");

expect(result!.ok).toBe(false);

if (!result!.ok) {

expect(result!.code, result!.error).toBe(PLUGIN_INSTALL_ERROR_CODE.SECURITY_SCAN_BLOCKED);

expect(result!.error).toContain("npm installs are disabled by policy");

}

expect(vi.mocked(runCommandWithTimeout)).toHaveBeenCalledTimes(1);

expect(vi.mocked(runCommandWithTimeout).mock.calls[0]?.[0]).toEqual([

"npm",

"view",

"@acme/policy-preflight-plugin@1.0.0",

`${packageName}@1.0.0`,

"name",

"version",

"dist.integrity",

expect(requests[0]?.sourcePathKind).toBe("file");

expect(path.basename(requests[0]?.sourcePath ?? "")).toBe("npm-package-metadata.json");

expect(requests[0]?.plugin?.contentType).toBe("package");

expect(captured.events).toHaveLength(1);

expect(captured.events[0]).toMatchObject({

action: "plugin.audit.failed",

outcome: "denied",

target: { kind: "plugin", name: packageName },

attributes: {

source_family: "npm",

mode: "install",

},

});

});

it("reports effective install mode to policy when requested npm update has no installed target", async () => {

if (!params.skipPolicyPreflight) {

const preflightPolicyResult = await runInstallSourceScan({

subject: `Plugin "${expectedPluginId ?? params.packageName}"`,

pluginId: expectedPluginId ?? params.packageName,

mode: effectiveMode,

sourceFamily: "npm",

scan: async () =>

await preflightPluginNpmInstallPolicy({

config: params.config,

}): Promise<Extract<InstallPluginResult, { ok: false }> | null> {

const scanResult = await runInstallSourceScan({

subject: `Plugin "${params.pluginId}"`,

pluginId: params.pluginId,

mode: params.mode,

sourceFamily:

params.requestKind === "plugin-npm"

? "npm"

: params.requestKind === "plugin-archive"

? "archive"

: params.requestKind === "plugin-dir"

? "directory"

: params.requestKind === "plugin-file"

? "file"

: "installed-package",

scan: async () =>

await params.runtime.scanInstalledPackageDependencyTree({

...(params.additionalDependencyPackageDirs

);

const preflightPolicyResult = await runInstallSourceScan({

subject: `Plugin "${expectedPluginId ?? parsedSpec.name}"`,

pluginId: expectedPluginId ?? parsedSpec.name,

mode: effectiveMode,

sourceFamily: "npm",

scan: async () =>

await preflightPluginNpmInstallPolicy({

config: params.config,