Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.
JavaScript 3d-generationai-agentsanimationavatardigital-humangenerative-aiglbgltfimage-to-3dllmmcpmcp-servermodel-context-protocolsolanatext-to-3dthreejsweb-componentswebglwebxrx402
import { describe, expect, it } from "vitest";
import { InterventionChecker } from "../src/core/InterventionChecker.js";
import { DEFAULT_SECURITY_BLACKLIST } from "../src/core/defaultSecurityBlacklist.js";
describe("InterventionChecker", () => {
describe("shouldIntervene", () => {
it("should return never when config is undefined", () => {
const result = InterventionChecker.shouldIntervene({
config: void 0,
securityBlacklist: [],
// Disable blacklist for this test
toolArgs: {}
});
expect(result).toBe("never");
});
it("should return the policy when config is a simple string", () => {
expect(
InterventionChecker.shouldIntervene({
config: "never",
securityBlacklist: [],
// Disable blacklist for this test
toolArgs: {}
})
).toBe("never");
expect(
InterventionChecker.shouldIntervene({
config: "required",
securityBlacklist: [],
// Disable blacklist for this test
toolArgs: {}
})
).toBe("required");
});
it("should match rules in order and return first match", () => {
const config = [
{ match: { command: "ls:*" }, policy: "never" },
{ match: { command: "git commit:*" }, policy: "required" },
{ policy: "required" }
// Default rule
];
expect(
InterventionChecker.shouldIntervene({
config,
securityBlacklist: [],
// Disable blacklist for this test
toolArgs: { command: "ls:" }
})
).toBe("never");
expect(
InterventionChecker.shouldIntervene({
config,
securityBlacklist: [],
// Disable blacklist for this test
toolArgs: { command: "git commit:" }
})
).toBe("required");
expect(
InterventionChecker.shouldIntervene({
config,
securityBlacklist: [],
// Disable blacklist for this test
toolArgs: { command: "rm -rf /" }
})
).toBe("required");
});
it("should return require as default when no rule matches", () => {
const config = [{ match: { command: "ls:*" }, policy: "never" }];
const result = InterventionChecker.shouldIntervene({
config,
securityBlacklist: [],
// Disable blacklist for this test
toolArgs: { command: "rm -rf /" }
});
expect(result).toBe("required");
});
it("should handle multiple parameter matching", () => {
const config = [
{
match: {
command: "git add:*",
path: "/Users/project/*"
},
policy: "never"
},
{ policy: "required" }
];
expect(
InterventionChecker.shouldIntervene({
config,
securityBlacklist: [],
// Disable blacklist for this test
toolArgs: {
command: "git add:.",
path: "/Users/project/file.ts"
}
})
).toBe("never");
expect(
InterventionChecker.shouldIntervene({
config,
securityBlacklist: [],
// Disable blacklist for this test
toolArgs: {
command: "git add:.",
path: "/tmp/file.ts"
}
})
).toBe("required");
});
it("should handle default rule without match", () => {
const config = [
{ match: { command: "ls:*" }, policy: "never" },
{ policy: "required" }
// Default rule
];
const result = InterventionChecker.shouldIntervene({
config,
securityBlacklist: [],
// Disable blacklist for this test
toolArgs: { command: "anything" }
});
expect(result).toBe("required");
});
});
describe("matchPattern", () => {
it("should match exact strings", () => {
expect(InterventionChecker["matchPattern"]("hello", "hello")).toBe(true);
expect(InterventionChecker["matchPattern"]("hello", "world")).toBe(false);
});
it("should match wildcard patterns", () => {
expect(InterventionChecker["matchPattern"]("*.ts", "file.ts")).toBe(true);
expect(InterventionChecker["matchPattern"]("*.ts", "file.js")).toBe(false);
expect(InterventionChecker["matchPattern"]("test*", "test123")).toBe(true);
expect(InterventionChecker["matchPattern"]("test*", "abc123")).toBe(false);
});
it("should match colon-based prefix patterns", () => {
expect(InterventionChecker["matchPattern"]("git add:*", "git add:")).toBe(true);
expect(InterventionChecker["matchPattern"]("git add:*", "git add:.")).toBe(true);
expect(InterventionChecker["matchPattern"]("git add:*", "git add:--all")).toBe(true);
expect(InterventionChecker["matchPattern"]("git add:*", "git commit")).toBe(false);
});
it("should match path patterns", () => {
expect(
InterventionChecker["matchPattern"]("/Users/project/*", "/Users/project/file.ts")
).toBe(true);
expect(InterventionChecker["matchPattern"]("/Users/project/*", "/tmp/file.ts")).toBe(false);
});
});
describe("matchesArgument", () => {
it("should match exact type", () => {
const matcher = { pattern: "git add", type: "exact" };
expect(InterventionChecker["matchesArgument"](matcher, "git add")).toBe(true);
expect(InterventionChecker["matchesArgument"](matcher, "git add:.")).toBe(false);
});
it("should match prefix type", () => {
const matcher = { pattern: "git add", type: "prefix" };
expect(InterventionChecker["matchesArgument"](matcher, "git add")).toBe(true);
expect(InterventionChecker["matchesArgument"](matcher, "git add:.")).toBe(true);
expect(InterventionChecker["matchesArgument"](matcher, "git commit")).toBe(false);
});
it("should match wildcard type", () => {
const matcher = { pattern: "git *", type: "wildcard" };
expect(InterventionChecker["matchesArgument"](matcher, "git add")).toBe(true);
expect(InterventionChecker["matchesArgument"](matcher, "git commit")).toBe(true);
expect(InterventionChecker["matchesArgument"](matcher, "npm install")).toBe(false);
});
it("should match regex type", () => {
const matcher = { pattern: "^git (add|commit)", type: "regex" };
expect(InterventionChecker["matchesArgument"](matcher, "git add")).toBe(true);
expect(InterventionChecker["matchesArgument"](matcher, "git commit")).toBe(true);
expect(InterventionChecker["matchesArgument"](matcher, "git push")).toBe(false);
});
it("should handle simple string matcher", () => {
expect(InterventionChecker["matchesArgument"]("git add:*", "git add:.")).toBe(true);
expect(InterventionChecker["matchesArgument"]("*.ts", "file.ts")).toBe(true);
expect(InterventionChecker["matchesArgument"]("exact", "exact")).toBe(true);
});
});
describe("generateToolKey", () => {
it("should generate key without args hash", () => {
const key = InterventionChecker.generateToolKey("web-browsing", "crawlSinglePage");
expect(key).toBe("web-browsing/crawlSinglePage");
});
it("should generate key with args hash", () => {
const key = InterventionChecker.generateToolKey("bash", "bash", "a1b2c3");
expect(key).toBe("bash/bash#a1b2c3");
});
});
describe("hashArguments", () => {
it("should generate consistent hash for same arguments", () => {
const args1 = { command: "ls -la", path: "/tmp" };
const args2 = { command: "ls -la", path: "/tmp" };
const hash1 = InterventionChecker.hashArguments(args1);
const hash2 = InterventionChecker.hashArguments(args2);
expect(hash1).toBe(hash2);
});
it("should generate different hash for different arguments", () => {
const args1 = { command: "ls -la" };
const args2 = { command: "ls -l" };
const hash1 = InterventionChecker.hashArguments(args1);
const hash2 = InterventionChecker.hashArguments(args2);
expect(hash1).not.toBe(hash2);
});
it("should handle key order independence", () => {
const args1 = { a: 1, b: 2 };
const args2 = { b: 2, a: 1 };
const hash1 = InterventionChecker.hashArguments(args1);
const hash2 = InterventionChecker.hashArguments(args2);
expect(hash1).toBe(hash2);
});
it("should handle empty arguments", () => {
const hash = InterventionChecker.hashArguments({});
expect(hash).toBeDefined();
expect(typeof hash).toBe("string");
});
it("should handle complex nested objects", () => {
const args = {
config: { nested: { value: "test" } },
array: [1, 2, 3]
};
const hash = InterventionChecker.hashArguments(args);
expect(hash).toBeDefined();
expect(typeof hash).toBe("string");
});
});
describe("checkSecurityBlacklist", () => {
it("should return not blocked when blacklist is empty", () => {
const result = InterventionChecker.checkSecurityBlacklist([], { command: "rm -rf /" });
expect(result.blocked).toBe(false);
expect(result.reason).toBeUndefined();
});
describe("with DEFAULT_SECURITY_BLACKLIST", () => {
it("should block dangerous rm -rf ~/ command", () => {
const result = InterventionChecker.checkSecurityBlacklist(DEFAULT_SECURITY_BLACKLIST, {
command: "rm -rf ~/"
});
expect(result.blocked).toBe(true);
expect(result.reason).toBe("Recursive deletion of home directory is extremely dangerous");
});
it("should block rm -rf on macOS home directory", () => {
const result = InterventionChecker.checkSecurityBlacklist(DEFAULT_SECURITY_BLACKLIST, {
command: "rm -rf /Users/alice"
});
expect(result.blocked).toBe(true);
expect(result.reason).toBe("Recursive deletion of home directory is extremely dangerous");
});
it("should block rm -rf on Linux home directory", () => {
const result = InterventionChecker.checkSecurityBlacklist(DEFAULT_SECURITY_BLACKLIST, {
command: "rm -rf /home/alice"
});
expect(result.blocked).toBe(true);
expect(result.reason).toBe("Recursive deletion of home directory is extremely dangerous");
});
it("should block rm -rf with $HOME variable", () => {
const result = InterventionChecker.checkSecurityBlacklist(DEFAULT_SECURITY_BLACKLIST, {
command: "rm -rf $HOME"
});
expect(result.blocked).toBe(true);
expect(result.reason).toBe("Recursive deletion of home directory is extremely dangerous");
});
it("should block rm -rf / command", () => {
const result = InterventionChecker.checkSecurityBlacklist(DEFAULT_SECURITY_BLACKLIST, {
command: "rm -rf /"
});
expect(result.blocked).toBe(true);
expect(result.reason).toBe("Recursive deletion of root directory will destroy the system");
});
it("should allow safe rm commands", () => {
const result = InterventionChecker.checkSecurityBlacklist(DEFAULT_SECURITY_BLACKLIST, {
command: "rm -rf /tmp/test-folder"
});
expect(result.blocked).toBe(false);
});
it("should block fork bomb", () => {
const result = InterventionChecker.checkSecurityBlacklist(DEFAULT_SECURITY_BLACKLIST, {
command: ":(){ :|:& };:"
});
expect(result.blocked).toBe(true);
expect(result.reason).toBe("Fork bomb can crash the system");
});
it("should block dangerous dd commands to disk devices", () => {
const result = InterventionChecker.checkSecurityBlacklist(DEFAULT_SECURITY_BLACKLIST, {
command: "dd if=/dev/zero of=/dev/sda"
});
expect(result.blocked).toBe(true);
expect(result.reason).toBe("Writing random data to disk devices can destroy data");
});
it("should block reading .env files via command", () => {
const result = InterventionChecker.checkSecurityBlacklist(DEFAULT_SECURITY_BLACKLIST, {
command: "cat .env"
});
expect(result.blocked).toBe(true);
expect(result.reason).toBe(
"Reading .env files may leak sensitive credentials and API keys"
);
});
it("should block reading .env files via path", () => {
const result = InterventionChecker.checkSecurityBlacklist(DEFAULT_SECURITY_BLACKLIST, {
path: "/project/.env.local"
});
expect(result.blocked).toBe(true);
expect(result.reason).toBe(
"Reading .env files may leak sensitive credentials and API keys"
);
});
it("should block reading SSH private keys via command", () => {
const result = InterventionChecker.checkSecurityBlacklist(DEFAULT_SECURITY_BLACKLIST, {
command: "cat ~/.ssh/id_rsa"
});
expect(result.blocked).toBe(true);
expect(result.reason).toBe("Reading SSH private keys can compromise system security");
});
it("should block reading SSH private keys via path", () => {
const result = InterventionChecker.checkSecurityBlacklist(DEFAULT_SECURITY_BLACKLIST, {
path: "/home/user/.ssh/id_ed25519"
});
expect(result.blocked).toBe(true);
expect(result.reason).toBe("Reading SSH private keys can compromise system security");
});
it("should allow reading SSH public keys", () => {
const result = InterventionChecker.checkSecurityBlacklist(DEFAULT_SECURITY_BLACKLIST, {
command: "cat ~/.ssh/id_rsa.pub"
});
expect(result.blocked).toBe(false);
});
it("should block reading AWS credentials via command", () => {
const result = InterventionChecker.checkSecurityBlacklist(DEFAULT_SECURITY_BLACKLIST, {
command: "cat ~/.aws/credentials"
});
expect(result.blocked).toBe(true);
expect(result.reason).toBe("Accessing AWS credentials can leak cloud access keys");
});
it("should block reading AWS credentials via path", () => {
const result = InterventionChecker.checkSecurityBlacklist(DEFAULT_SECURITY_BLACKLIST, {
path: "/home/user/.aws/credentials"
});
expect(result.blocked).toBe(true);
expect(result.reason).toBe("Accessing AWS credentials can leak cloud access keys");
});
it("should block reading Docker config", () => {
const result = InterventionChecker.checkSecurityBlacklist(DEFAULT_SECURITY_BLACKLIST, {
command: "less ~/.docker/config.json"
});
expect(result.blocked).toBe(true);
expect(result.reason).toBe("Reading Docker config may expose registry credentials");
});
it("should block reading Kubernetes config", () => {
const result = InterventionChecker.checkSecurityBlacklist(DEFAULT_SECURITY_BLACKLIST, {
path: "/home/user/.kube/config"
});
expect(result.blocked).toBe(true);
expect(result.reason).toBe("Reading Kubernetes config may expose cluster credentials");
});
it("should block reading Git credentials", () => {
const result = InterventionChecker.checkSecurityBlacklist(DEFAULT_SECURITY_BLACKLIST, {
command: "cat ~/.git-credentials"
});
expect(result.blocked).toBe(true);
expect(result.reason).toBe("Reading Git credentials file may leak access tokens");
});
it("should block reading npm token file", () => {
const result = InterventionChecker.checkSecurityBlacklist(DEFAULT_SECURITY_BLACKLIST, {
path: "/home/user/.npmrc"
});
expect(result.blocked).toBe(true);
expect(result.reason).toBe(
"Reading npm token file may expose package registry credentials"
);
});
it("should block reading shell history files", () => {
const result = InterventionChecker.checkSecurityBlacklist(DEFAULT_SECURITY_BLACKLIST, {
command: "cat ~/.bash_history"
});
expect(result.blocked).toBe(true);
expect(result.reason).toBe(
"Reading history files may expose sensitive commands and credentials"
);
});
it("should block reading GCP credentials", () => {
const result = InterventionChecker.checkSecurityBlacklist(DEFAULT_SECURITY_BLACKLIST, {
path: "/home/user/.config/gcloud/application_default_credentials.json"
});
expect(result.blocked).toBe(true);
expect(result.reason).toBe("Reading GCP credentials may leak cloud service account keys");
});
});
describe("with custom blacklist", () => {
it("should work with multiple parameter matching", () => {
const blacklist = [
{
description: "Dangerous operation on system files",
match: {
command: { pattern: "rm.*", type: "regex" },
path: "/etc/*"
}
}
];
expect(
InterventionChecker.checkSecurityBlacklist(blacklist, {
command: "rm -rf",
path: "/etc/passwd"
}).blocked
).toBe(true);
expect(
InterventionChecker.checkSecurityBlacklist(blacklist, {
command: "rm -rf",
path: "/tmp/file"
}).blocked
).toBe(false);
expect(
InterventionChecker.checkSecurityBlacklist(blacklist, {
command: "cat",
path: "/etc/passwd"
}).blocked
).toBe(false);
});
});
});
describe("shouldIntervene with security blacklist", () => {
describe("with default blacklist behavior", () => {
it("should block dangerous commands even in auto-run mode", () => {
const result = InterventionChecker.shouldIntervene({
config: "never",
// Not passing securityBlacklist - should use DEFAULT_SECURITY_BLACKLIST
toolArgs: { command: "rm -rf ~/" }
});
expect(result).toBe("required");
});
it("should block dangerous commands even with no config", () => {
const result = InterventionChecker.shouldIntervene({
config: void 0,
// Not passing securityBlacklist - should use DEFAULT_SECURITY_BLACKLIST
toolArgs: { command: "rm -rf /" }
});
expect(result).toBe("required");
});
it("should allow safe commands to follow normal intervention rules", () => {
const result = InterventionChecker.shouldIntervene({
config: "never",
// Not passing securityBlacklist - should use DEFAULT_SECURITY_BLACKLIST
toolArgs: { command: "ls -la" }
});
expect(result).toBe("never");
});
it("should block reading sensitive files", () => {
const result = InterventionChecker.shouldIntervene({
config: "never",
// Not passing securityBlacklist - should use DEFAULT_SECURITY_BLACKLIST
toolArgs: { command: "cat .env" }
});
expect(result).toBe("required");
});
});
describe("with custom blacklist replacement", () => {
it("should use custom blacklist instead of default when provided", () => {
const customBlacklist = [
{
description: "Block all npm commands in production",
match: {
command: { pattern: "npm.*", type: "regex" }
}
}
];
expect(
InterventionChecker.shouldIntervene({
config: "never",
securityBlacklist: customBlacklist,
toolArgs: { command: "npm install" }
})
).toBe("required");
expect(
InterventionChecker.shouldIntervene({
config: "never",
securityBlacklist: customBlacklist,
toolArgs: { command: "rm -rf ~/" }
})
).toBe("never");
});
it("should support extending default blacklist with custom rules", () => {
const extendedBlacklist = [
...DEFAULT_SECURITY_BLACKLIST,
{
description: "Block access to production database",
match: {
command: { pattern: ".*psql.*production.*", type: "regex" }
}
}
];
expect(
InterventionChecker.shouldIntervene({
config: "never",
securityBlacklist: extendedBlacklist,
toolArgs: { command: "rm -rf ~/" }
})
).toBe("required");
expect(
InterventionChecker.shouldIntervene({
config: "never",
securityBlacklist: extendedBlacklist,
toolArgs: { command: "psql -h production.db" }
})
).toBe("required");
expect(
InterventionChecker.shouldIntervene({
config: "never",
securityBlacklist: extendedBlacklist,
toolArgs: { command: "psql -h localhost" }
})
).toBe("never");
});
it("should allow disabling security blacklist by passing empty array", () => {
const result = InterventionChecker.shouldIntervene({
config: "never",
securityBlacklist: [],
// Explicitly disable blacklist
toolArgs: { command: "rm -rf ~/" }
});
expect(result).toBe("never");
});
it("should support project-specific blacklist rules", () => {
const projectBlacklist = [
{
description: "Block modifying package.json in CI",
match: {
path: { pattern: ".*/package\\.json$", type: "regex" },
command: { pattern: "(vim|nano|vi|emacs|code|sed).*", type: "regex" }
}
}
];
expect(
InterventionChecker.shouldIntervene({
config: "never",
securityBlacklist: projectBlacklist,
toolArgs: {
command: "vim package.json",
path: "/project/package.json"
}
})
).toBe("required");
expect(
InterventionChecker.shouldIntervene({
config: "never",
securityBlacklist: projectBlacklist,
toolArgs: {
command: "cat package.json",
path: "/project/package.json"
}
})
).toBe("never");
});
});
});
describe("Integration scenarios", () => {
it("should handle Bash tool scenario", () => {
const config = [
{ match: { command: "ls:*" }, policy: "never" },
{ match: { command: "git add:*" }, policy: "required" },
{ match: { command: "git commit:*" }, policy: "required" },
{ match: { command: "rm:*" }, policy: "required" },
{ policy: "required" }
];
expect(
InterventionChecker.shouldIntervene({
config,
securityBlacklist: [],
// Disable blacklist for this test
toolArgs: { command: "ls:" }
})
).toBe("never");
expect(
InterventionChecker.shouldIntervene({
config,
securityBlacklist: [],
// Disable blacklist for this test
toolArgs: { command: "git add:." }
})
).toBe("required");
expect(
InterventionChecker.shouldIntervene({
config,
securityBlacklist: [],
// Disable blacklist for this test
toolArgs: { command: "git commit:-m" }
})
).toBe("required");
expect(
InterventionChecker.shouldIntervene({
config,
securityBlacklist: [],
// Disable blacklist for this test
toolArgs: { command: "rm:-rf" }
})
).toBe("required");
expect(
InterventionChecker.shouldIntervene({
config,
securityBlacklist: [],
// Disable blacklist for this test
toolArgs: { command: "npm install" }
})
).toBe("required");
});
it("should handle LocalSystem tool scenario", () => {
const config = [
{ match: { path: "/Users/project/*" }, policy: "never" },
{ policy: "required" }
];
expect(
InterventionChecker.shouldIntervene({
config,
securityBlacklist: [],
// Disable blacklist for this test
toolArgs: { path: "/Users/project/file.ts" }
})
).toBe("never");
expect(
InterventionChecker.shouldIntervene({
config,
securityBlacklist: [],
// Disable blacklist for this test
toolArgs: { path: "/tmp/file.ts" }
})
).toBe("required");
});
it("should handle Web Browsing tool with simple policy", () => {
const config = "required";
expect(
InterventionChecker.shouldIntervene({
config,
securityBlacklist: [],
// Disable blacklist for this test
toolArgs: { url: "https://example.com" }
})
).toBe("required");
});
it("should handle security blacklist overriding user config", () => {
const config = "never";
const blacklist = DEFAULT_SECURITY_BLACKLIST;
expect(
InterventionChecker.shouldIntervene({
config,
securityBlacklist: blacklist,
toolArgs: { command: "rm -rf /" }
})
).toBe("required");
expect(
InterventionChecker.shouldIntervene({
config,
securityBlacklist: blacklist,
toolArgs: { command: "ls -la" }
})
).toBe("never");
});
});
});