palaryn 0.1.0 → 0.3.2

package/dist/tests/unit/policy-engine.test.js

@@ -1341,5 +1341,471 @@ rules:
             expect(result.rule_name).toBe('__ssrf_protection');
         });
     });
+    // -----------------------------------------------------------------------
+    // New tool type conditions
+    // -----------------------------------------------------------------------
+    describe('New tool type conditions', () => {
+        /** Build a minimal valid ToolCall for testing new conditions. */
+        function makeToolCall(overrides = {}) {
+            return {
+                tool_call_id: 'tc_test',
+                task_id: 'task_test',
+                workspace_id: 'ws_test',
+                actor: { type: 'agent', id: 'agent_test' },
+                source: { platform: 'test' },
+                tool: { name: 'test.tool', capability: 'read' },
+                args: {},
+                ...overrides,
+            };
+        }
+        // --- file_paths ---
+        describe('file_paths', () => {
+            it('matches when file path matches glob pattern', () => {
+                const pack = {
+                    name: 'file_paths_test',
+                    version: '1.0.0',
+                    rules: [
+                        {
+                            name: 'deny-env-files',
+                            effect: 'DENY',
+                            priority: 1,
+                            conditions: { file_paths: ['*.env'] },
+                        },
+                    ],
+                };
+                const engine = engine_1.PolicyEngine.fromPack(pack, 'ALLOW');
+                const tc = makeToolCall({ args: { path: '.env' } });
+                expect(engine.evaluate(tc).decision).toBe('deny');
+            });
+            it('does not match when file path does not match', () => {
+                const pack = {
+                    name: 'file_paths_no_match',
+                    version: '1.0.0',
+                    rules: [
+                        {
+                            name: 'deny-env-files',
+                            effect: 'DENY',
+                            priority: 1,
+                            conditions: { file_paths: ['*.env'] },
+                        },
+                    ],
+                };
+                const engine = engine_1.PolicyEngine.fromPack(pack, 'ALLOW');
+                const tc = makeToolCall({ args: { path: 'readme.md' } });
+                expect(engine.evaluate(tc).decision).toBe('allow');
+            });
+            it('does not match when no path arg present', () => {
+                const pack = {
+                    name: 'file_paths_no_path',
+                    version: '1.0.0',
+                    rules: [
+                        {
+                            name: 'deny-env-files',
+                            effect: 'DENY',
+                            priority: 1,
+                            conditions: { file_paths: ['*.env'] },
+                        },
+                    ],
+                };
+                const engine = engine_1.PolicyEngine.fromPack(pack, 'ALLOW');
+                const tc = makeToolCall({ args: {} });
+                expect(engine.evaluate(tc).decision).toBe('allow');
+            });
+        });
+        // --- file_paths_blocklist ---
+        describe('file_paths_blocklist', () => {
+            it('blocks when path matches blocklist pattern', () => {
+                const pack = {
+                    name: 'file_blocklist_test',
+                    version: '1.0.0',
+                    rules: [
+                        {
+                            name: 'allow-all-except-secrets',
+                            effect: 'ALLOW',
+                            priority: 1,
+                            conditions: { file_paths_blocklist: ['/etc/**'] },
+                        },
+                        {
+                            name: 'deny-all',
+                            effect: 'DENY',
+                            priority: 100,
+                            conditions: {},
+                        },
+                    ],
+                };
+                const engine = engine_1.PolicyEngine.fromPack(pack);
+                const tc = makeToolCall({ args: { path: '/etc/passwd' } });
+                // The ALLOW rule won't match because file_paths_blocklist blocks it, so deny-all fires
+                expect(engine.evaluate(tc).decision).toBe('deny');
+            });
+            it('allows when path does not match blocklist', () => {
+                const pack = {
+                    name: 'file_blocklist_allow',
+                    version: '1.0.0',
+                    rules: [
+                        {
+                            name: 'allow-all-except-secrets',
+                            effect: 'ALLOW',
+                            priority: 1,
+                            conditions: { file_paths_blocklist: ['/etc/**'] },
+                        },
+                        {
+                            name: 'deny-all',
+                            effect: 'DENY',
+                            priority: 100,
+                            conditions: {},
+                        },
+                    ],
+                };
+                const engine = engine_1.PolicyEngine.fromPack(pack);
+                const tc = makeToolCall({ args: { path: '/home/user/file.txt' } });
+                expect(engine.evaluate(tc).decision).toBe('allow');
+            });
+        });
+        // --- file_extensions ---
+        describe('file_extensions', () => {
+            it('matches when file extension is in list', () => {
+                const pack = {
+                    name: 'file_ext_test',
+                    version: '1.0.0',
+                    rules: [
+                        {
+                            name: 'deny-key-files',
+                            effect: 'DENY',
+                            priority: 1,
+                            conditions: { file_extensions: ['.key', '.pem'] },
+                        },
+                    ],
+                };
+                const engine = engine_1.PolicyEngine.fromPack(pack, 'ALLOW');
+                const tc = makeToolCall({ args: { path: '/certs/server.key' } });
+                expect(engine.evaluate(tc).decision).toBe('deny');
+            });
+            it('does not match when extension not in list', () => {
+                const pack = {
+                    name: 'file_ext_no_match',
+                    version: '1.0.0',
+                    rules: [
+                        {
+                            name: 'deny-key-files',
+                            effect: 'DENY',
+                            priority: 1,
+                            conditions: { file_extensions: ['.key', '.pem'] },
+                        },
+                    ],
+                };
+                const engine = engine_1.PolicyEngine.fromPack(pack, 'ALLOW');
+                const tc = makeToolCall({ args: { path: '/app/config.json' } });
+                expect(engine.evaluate(tc).decision).toBe('allow');
+            });
+        });
+        // --- sql_tables ---
+        describe('sql_tables', () => {
+            it('matches when query references matching table', () => {
+                const pack = {
+                    name: 'sql_tables_test',
+                    version: '1.0.0',
+                    rules: [
+                        {
+                            name: 'deny-users-table',
+                            effect: 'DENY',
+                            priority: 1,
+                            conditions: { sql_tables: ['users'] },
+                        },
+                    ],
+                };
+                const engine = engine_1.PolicyEngine.fromPack(pack, 'ALLOW');
+                const tc = makeToolCall({ args: { query: 'SELECT * FROM users WHERE id = 1' } });
+                expect(engine.evaluate(tc).decision).toBe('deny');
+            });
+            it('does not match when table not found in query', () => {
+                const pack = {
+                    name: 'sql_tables_no_match',
+                    version: '1.0.0',
+                    rules: [
+                        {
+                            name: 'deny-users-table',
+                            effect: 'DENY',
+                            priority: 1,
+                            conditions: { sql_tables: ['users'] },
+                        },
+                    ],
+                };
+                const engine = engine_1.PolicyEngine.fromPack(pack, 'ALLOW');
+                const tc = makeToolCall({ args: { query: 'SELECT * FROM orders WHERE id = 1' } });
+                expect(engine.evaluate(tc).decision).toBe('allow');
+            });
+        });
+        // --- sql_tables_blocklist ---
+        describe('sql_tables_blocklist', () => {
+            it('blocks when query references blocked table (FROM, JOIN, INTO, UPDATE)', () => {
+                const pack = {
+                    name: 'sql_blocklist_test',
+                    version: '1.0.0',
+                    rules: [
+                        {
+                            name: 'allow-except-secrets',
+                            effect: 'ALLOW',
+                            priority: 1,
+                            conditions: { sql_tables_blocklist: ['secrets'] },
+                        },
+                        {
+                            name: 'deny-all',
+                            effect: 'DENY',
+                            priority: 100,
+                            conditions: {},
+                        },
+                    ],
+                };
+                const engine = engine_1.PolicyEngine.fromPack(pack);
+                // FROM
+                expect(engine.evaluate(makeToolCall({ args: { query: 'SELECT * FROM secrets' } })).decision).toBe('deny');
+                // JOIN
+                expect(engine.evaluate(makeToolCall({ args: { query: 'SELECT * FROM orders JOIN secrets ON 1=1' } })).decision).toBe('deny');
+                // INTO
+                expect(engine.evaluate(makeToolCall({ args: { query: 'INSERT INTO secrets VALUES (1)' } })).decision).toBe('deny');
+                // UPDATE
+                expect(engine.evaluate(makeToolCall({ args: { query: 'UPDATE secrets SET val = 1' } })).decision).toBe('deny');
+            });
+            it('allows when no blocked tables referenced', () => {
+                const pack = {
+                    name: 'sql_blocklist_allow',
+                    version: '1.0.0',
+                    rules: [
+                        {
+                            name: 'allow-except-secrets',
+                            effect: 'ALLOW',
+                            priority: 1,
+                            conditions: { sql_tables_blocklist: ['secrets'] },
+                        },
+                        {
+                            name: 'deny-all',
+                            effect: 'DENY',
+                            priority: 100,
+                            conditions: {},
+                        },
+                    ],
+                };
+                const engine = engine_1.PolicyEngine.fromPack(pack);
+                const tc = makeToolCall({ args: { query: 'SELECT * FROM orders' } });
+                expect(engine.evaluate(tc).decision).toBe('allow');
+            });
+        });
+        // --- sql_statements ---
+        describe('sql_statements', () => {
+            it('matches SELECT statement', () => {
+                const pack = {
+                    name: 'sql_stmt_select',
+                    version: '1.0.0',
+                    rules: [
+                        {
+                            name: 'deny-selects',
+                            effect: 'DENY',
+                            priority: 1,
+                            conditions: { sql_statements: ['SELECT'] },
+                        },
+                    ],
+                };
+                const engine = engine_1.PolicyEngine.fromPack(pack, 'ALLOW');
+                const tc = makeToolCall({ args: { query: 'SELECT * FROM users' } });
+                expect(engine.evaluate(tc).decision).toBe('deny');
+            });
+            it('matches INSERT statement', () => {
+                const pack = {
+                    name: 'sql_stmt_insert',
+                    version: '1.0.0',
+                    rules: [
+                        {
+                            name: 'deny-inserts',
+                            effect: 'DENY',
+                            priority: 1,
+                            conditions: { sql_statements: ['INSERT'] },
+                        },
+                    ],
+                };
+                const engine = engine_1.PolicyEngine.fromPack(pack, 'ALLOW');
+                const tc = makeToolCall({ args: { query: 'INSERT INTO users VALUES (1)' } });
+                expect(engine.evaluate(tc).decision).toBe('deny');
+            });
+            it('does not match when statement type differs', () => {
+                const pack = {
+                    name: 'sql_stmt_no_match',
+                    version: '1.0.0',
+                    rules: [
+                        {
+                            name: 'deny-deletes',
+                            effect: 'DENY',
+                            priority: 1,
+                            conditions: { sql_statements: ['DELETE'] },
+                        },
+                    ],
+                };
+                const engine = engine_1.PolicyEngine.fromPack(pack, 'ALLOW');
+                const tc = makeToolCall({ args: { query: 'SELECT * FROM users' } });
+                expect(engine.evaluate(tc).decision).toBe('allow');
+            });
+        });
+        // --- shell_commands ---
+        describe('shell_commands', () => {
+            it('matches when command is in allowed list', () => {
+                const pack = {
+                    name: 'shell_cmd_test',
+                    version: '1.0.0',
+                    rules: [
+                        {
+                            name: 'deny-rm',
+                            effect: 'DENY',
+                            priority: 1,
+                            conditions: { shell_commands: ['rm'] },
+                        },
+                    ],
+                };
+                const engine = engine_1.PolicyEngine.fromPack(pack, 'ALLOW');
+                const tc = makeToolCall({ args: { command: 'rm' } });
+                expect(engine.evaluate(tc).decision).toBe('deny');
+            });
+            it('does not match when command not in list', () => {
+                const pack = {
+                    name: 'shell_cmd_no_match',
+                    version: '1.0.0',
+                    rules: [
+                        {
+                            name: 'deny-rm',
+                            effect: 'DENY',
+                            priority: 1,
+                            conditions: { shell_commands: ['rm'] },
+                        },
+                    ],
+                };
+                const engine = engine_1.PolicyEngine.fromPack(pack, 'ALLOW');
+                const tc = makeToolCall({ args: { command: 'ls' } });
+                expect(engine.evaluate(tc).decision).toBe('allow');
+            });
+        });
+        // --- shell_commands_blocklist ---
+        describe('shell_commands_blocklist', () => {
+            it('blocks when command is in blocklist', () => {
+                const pack = {
+                    name: 'shell_blocklist_test',
+                    version: '1.0.0',
+                    rules: [
+                        {
+                            name: 'allow-except-rm',
+                            effect: 'ALLOW',
+                            priority: 1,
+                            conditions: { shell_commands_blocklist: ['rm', 'shutdown'] },
+                        },
+                        {
+                            name: 'deny-all',
+                            effect: 'DENY',
+                            priority: 100,
+                            conditions: {},
+                        },
+                    ],
+                };
+                const engine = engine_1.PolicyEngine.fromPack(pack);
+                const tc = makeToolCall({ args: { command: 'rm' } });
+                // ALLOW rule won't match because blocklist fires, so deny-all fires
+                expect(engine.evaluate(tc).decision).toBe('deny');
+            });
+            it('allows when command not in blocklist', () => {
+                const pack = {
+                    name: 'shell_blocklist_allow',
+                    version: '1.0.0',
+                    rules: [
+                        {
+                            name: 'allow-except-rm',
+                            effect: 'ALLOW',
+                            priority: 1,
+                            conditions: { shell_commands_blocklist: ['rm', 'shutdown'] },
+                        },
+                        {
+                            name: 'deny-all',
+                            effect: 'DENY',
+                            priority: 100,
+                            conditions: {},
+                        },
+                    ],
+                };
+                const engine = engine_1.PolicyEngine.fromPack(pack);
+                const tc = makeToolCall({ args: { command: 'ls' } });
+                expect(engine.evaluate(tc).decision).toBe('allow');
+            });
+        });
+        // --- providers ---
+        describe('providers', () => {
+            it('matches when provider arg matches', () => {
+                const pack = {
+                    name: 'providers_test',
+                    version: '1.0.0',
+                    rules: [
+                        {
+                            name: 'deny-openai',
+                            effect: 'DENY',
+                            priority: 1,
+                            conditions: { providers: ['openai'] },
+                        },
+                    ],
+                };
+                const engine = engine_1.PolicyEngine.fromPack(pack, 'ALLOW');
+                const tc = makeToolCall({ args: { provider: 'openai' } });
+                expect(engine.evaluate(tc).decision).toBe('deny');
+            });
+            it('does not match when provider differs', () => {
+                const pack = {
+                    name: 'providers_no_match',
+                    version: '1.0.0',
+                    rules: [
+                        {
+                            name: 'deny-openai',
+                            effect: 'DENY',
+                            priority: 1,
+                            conditions: { providers: ['openai'] },
+                        },
+                    ],
+                };
+                const engine = engine_1.PolicyEngine.fromPack(pack, 'ALLOW');
+                const tc = makeToolCall({ args: { provider: 'claude' } });
+                expect(engine.evaluate(tc).decision).toBe('allow');
+            });
+        });
+        // --- provider_tool_types ---
+        describe('provider_tool_types', () => {
+            it('matches when provider_tool_type arg matches', () => {
+                const pack = {
+                    name: 'provider_types_test',
+                    version: '1.0.0',
+                    rules: [
+                        {
+                            name: 'deny-computer-use',
+                            effect: 'DENY',
+                            priority: 1,
+                            conditions: { provider_tool_types: ['computer_use'] },
+                        },
+                    ],
+                };
+                const engine = engine_1.PolicyEngine.fromPack(pack, 'ALLOW');
+                const tc = makeToolCall({ args: { provider_tool_type: 'computer_use' } });
+                expect(engine.evaluate(tc).decision).toBe('deny');
+            });
+            it('does not match when type differs', () => {
+                const pack = {
+                    name: 'provider_types_no_match',
+                    version: '1.0.0',
+                    rules: [
+                        {
+                            name: 'deny-computer-use',
+                            effect: 'DENY',
+                            priority: 1,
+                            conditions: { provider_tool_types: ['computer_use'] },
+                        },
+                    ],
+                };
+                const engine = engine_1.PolicyEngine.fromPack(pack, 'ALLOW');
+                const tc = makeToolCall({ args: { provider_tool_type: 'function' } });
+                expect(engine.evaluate(tc).decision).toBe('allow');
+            });
+        });
+    });
 });
 //# sourceMappingURL=policy-engine.test.js.map