@doingdev/opencode-claude-manager-plugin 0.1.64 → 0.1.66

package/dist/test/tool-approval-manager.test.js

@@ -1,260 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { ToolApprovalManager } from '../src/claude/tool-approval-manager.js';
-describe('ToolApprovalManager', () => {
-    describe('evaluate()', () => {
-        it('allows Skill tool by default policy', () => {
-            const manager = new ToolApprovalManager();
-            const result = manager.evaluate('Skill', { command: 'my-skill' });
-            expect(result).toEqual({ behavior: 'allow' });
-        });
-        it('allows read-only tools by default policy', () => {
-            const manager = new ToolApprovalManager();
-            expect(manager.evaluate('Read', { file_path: '/tmp/foo.ts' })).toEqual({
-                behavior: 'allow',
-            });
-            expect(manager.evaluate('Grep', { pattern: 'foo' })).toEqual({
-                behavior: 'allow',
-            });
-            expect(manager.evaluate('Glob', { pattern: '*.ts' })).toEqual({
-                behavior: 'allow',
-            });
-        });
-        it('allows edit tools by default policy', () => {
-            const manager = new ToolApprovalManager();
-            expect(manager.evaluate('Edit', {
-                file_path: '/tmp/foo.ts',
-                old_string: 'a',
-                new_string: 'b',
-            })).toEqual({ behavior: 'allow' });
-            expect(manager.evaluate('Write', {
-                file_path: '/tmp/foo.ts',
-                content: 'hello',
-            })).toEqual({ behavior: 'allow' });
-        });
-        it('denies bash rm -rf on root', () => {
-            const manager = new ToolApprovalManager();
-            const result = manager.evaluate('Bash', { command: 'rm -rf /' });
-            expect(result.behavior).toBe('deny');
-            if (result.behavior === 'deny') {
-                expect(result.message).toContain('rm -rf');
-            }
-        });
-        it('denies git push --force', () => {
-            const manager = new ToolApprovalManager();
-            const result = manager.evaluate('Bash', {
-                command: 'git push --force origin main',
-            });
-            expect(result.behavior).toBe('deny');
-            if (result.behavior === 'deny') {
-                expect(result.message).toContain('Force push');
-            }
-        });
-        it('denies git reset --hard', () => {
-            const manager = new ToolApprovalManager();
-            const result = manager.evaluate('Bash', {
-                command: 'git reset --hard HEAD',
-            });
-            expect(result.behavior).toBe('deny');
-            if (result.behavior === 'deny') {
-                expect(result.message).toContain('git reset --hard');
-            }
-        });
-        it('allows normal bash commands', () => {
-            const manager = new ToolApprovalManager();
-            expect(manager.evaluate('Bash', { command: 'ls -la' })).toEqual({
-                behavior: 'allow',
-            });
-            expect(manager.evaluate('Bash', { command: 'pnpm test' })).toEqual({
-                behavior: 'allow',
-            });
-        });
-        it('returns allow when disabled', () => {
-            const manager = new ToolApprovalManager({ enabled: false });
-            const result = manager.evaluate('Bash', { command: 'rm -rf /' });
-            expect(result).toEqual({ behavior: 'allow' });
-        });
-        it('allows tools when no rule matches (deny-list contract)', () => {
-            const manager = new ToolApprovalManager({
-                rules: [],
-            });
-            const result = manager.evaluate('SomeUnknownTool', {});
-            expect(result.behavior).toBe('allow');
-        });
-        it('first matching rule wins', () => {
-            const manager = new ToolApprovalManager({
-                rules: [
-                    {
-                        id: 'deny-all-bash',
-                        toolPattern: 'Bash',
-                        action: 'deny',
-                        denyMessage: 'No bash',
-                    },
-                    { id: 'allow-bash', toolPattern: 'Bash', action: 'allow' },
-                ],
-                defaultAction: 'allow',
-                enabled: true,
-            });
-            const result = manager.evaluate('Bash', { command: 'echo hi' });
-            expect(result.behavior).toBe('deny');
-        });
-        it('matches glob patterns in tool names', () => {
-            const manager = new ToolApprovalManager({
-                rules: [
-                    {
-                        id: 'deny-notebook',
-                        toolPattern: 'Notebook*',
-                        action: 'deny',
-                        denyMessage: 'No notebooks',
-                    },
-                ],
-                defaultAction: 'allow',
-                enabled: true,
-            });
-            expect(manager.evaluate('NotebookEdit', {}).behavior).toBe('deny');
-            expect(manager.evaluate('NotebookRead', {}).behavior).toBe('deny');
-            expect(manager.evaluate('Read', {}).behavior).toBe('allow');
-        });
-        it('matches inputPattern as substring of serialized input', () => {
-            const manager = new ToolApprovalManager({
-                rules: [
-                    {
-                        id: 'deny-secret-files',
-                        toolPattern: '*',
-                        inputPattern: '.env',
-                        action: 'deny',
-                        denyMessage: 'No .env access',
-                    },
-                ],
-                defaultAction: 'allow',
-                enabled: true,
-            });
-            expect(manager.evaluate('Read', { file_path: '/project/.env' }).behavior).toBe('deny');
-            expect(manager.evaluate('Read', { file_path: '/project/src/index.ts' }).behavior).toBe('allow');
-        });
-        it('records decisions in the log', () => {
-            const manager = new ToolApprovalManager();
-            manager.evaluate('Read', { file_path: '/tmp/foo.ts' });
-            const decisions = manager.getDecisions();
-            expect(decisions).toHaveLength(1);
-            expect(decisions[0].toolName).toBe('Read');
-            expect(decisions[0].action).toBe('allow');
-            expect(decisions[0].matchedRuleId).toBe('allow-read');
-        });
-    });
-    describe('policy management', () => {
-        it('addRule inserts at specified position', async () => {
-            const manager = new ToolApprovalManager({
-                rules: [],
-                enabled: true,
-                defaultAction: 'allow',
-            });
-            await manager.addRule({ id: 'a', toolPattern: 'A', action: 'allow' });
-            await manager.addRule({ id: 'b', toolPattern: 'B', action: 'allow' });
-            await manager.addRule({ id: 'c', toolPattern: 'C', action: 'deny' }, 1);
-            const rules = manager.getPolicy().rules;
-            expect(rules.map((r) => r.id)).toEqual(['a', 'c', 'b']);
-        });
-        it('addRule appends to end by default', async () => {
-            const manager = new ToolApprovalManager({
-                rules: [],
-                enabled: true,
-                defaultAction: 'allow',
-            });
-            await manager.addRule({ id: 'a', toolPattern: 'A', action: 'allow' });
-            await manager.addRule({ id: 'b', toolPattern: 'B', action: 'allow' });
-            expect(manager.getPolicy().rules.map((r) => r.id)).toEqual(['a', 'b']);
-        });
-        it('removeRule removes by ID and returns true', async () => {
-            const manager = new ToolApprovalManager();
-            const removed = await manager.removeRule('allow-read');
-            expect(removed).toBe(true);
-            expect(manager.getPolicy().rules.find((r) => r.id === 'allow-read')).toBeUndefined();
-        });
-        it('removeRule returns false for non-existent ID', async () => {
-            const manager = new ToolApprovalManager();
-            expect(await manager.removeRule('nonexistent')).toBe(false);
-        });
-        it('setPolicy replaces entire policy and normalizes defaultAction to allow', async () => {
-            const manager = new ToolApprovalManager();
-            await manager.setPolicy({
-                rules: [{ id: 'only', toolPattern: '*', action: 'deny' }],
-                defaultAction: 'allow',
-                enabled: true,
-            });
-            expect(manager.getPolicy().rules).toHaveLength(1);
-            expect(manager.getPolicy().defaultAction).toBe('allow');
-        });
-        it('setDefaultAction rejects deny', async () => {
-            const manager = new ToolApprovalManager({
-                rules: [],
-                enabled: true,
-            });
-            await expect(manager.setDefaultAction('deny')).rejects.toThrow(/defaultAction cannot be deny/);
-        });
-        it('setEnabled toggles the manager', async () => {
-            const manager = new ToolApprovalManager({
-                rules: [
-                    {
-                        id: 'deny-all',
-                        toolPattern: '*',
-                        action: 'deny',
-                        denyMessage: 'blocked',
-                    },
-                ],
-                enabled: true,
-            });
-            expect(manager.evaluate('Read', {}).behavior).toBe('deny');
-            await manager.setEnabled(false);
-            expect(manager.evaluate('Read', {}).behavior).toBe('allow');
-        });
-    });
-    describe('decision log', () => {
-        it('getDecisions returns most recent first', () => {
-            const manager = new ToolApprovalManager();
-            manager.evaluate('Read', {});
-            manager.evaluate('Grep', {});
-            manager.evaluate('Glob', {});
-            const decisions = manager.getDecisions();
-            expect(decisions[0].toolName).toBe('Glob');
-            expect(decisions[2].toolName).toBe('Read');
-        });
-        it('getDeniedDecisions filters to denials only', () => {
-            const manager = new ToolApprovalManager();
-            manager.evaluate('Read', {});
-            manager.evaluate('Bash', { command: 'rm -rf /' });
-            manager.evaluate('Grep', {});
-            const denied = manager.getDeniedDecisions();
-            expect(denied).toHaveLength(1);
-            expect(denied[0].toolName).toBe('Bash');
-        });
-        it('clearDecisions empties the log', () => {
-            const manager = new ToolApprovalManager();
-            manager.evaluate('Read', {});
-            manager.evaluate('Grep', {});
-            manager.clearDecisions();
-            expect(manager.getDecisions()).toHaveLength(0);
-        });
-        it('respects maxDecisions ring buffer limit', () => {
-            const manager = new ToolApprovalManager({}, 3);
-            manager.evaluate('Read', {});
-            manager.evaluate('Grep', {});
-            manager.evaluate('Glob', {});
-            manager.evaluate('Edit', {});
-            const decisions = manager.getDecisions();
-            expect(decisions).toHaveLength(3);
-            // Oldest (Read) should be evicted
-            expect(decisions.map((d) => d.toolName)).toEqual(['Edit', 'Glob', 'Grep']);
-        });
-        it('includes agentId when provided', () => {
-            const manager = new ToolApprovalManager();
-            manager.evaluate('Read', {}, { agentID: 'agent_123' });
-            expect(manager.getDecisions()[0].agentId).toBe('agent_123');
-        });
-        it('truncates inputPreview for large inputs', () => {
-            const manager = new ToolApprovalManager();
-            manager.evaluate('Read', { data: 'x'.repeat(1000) });
-            const decision = manager.getDecisions()[0];
-            expect(decision.inputPreview.length).toBeLessThanOrEqual(300);
-        });
-    });
-});

package/dist/test/transcript-append.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/transcript-append.test.js

@@ -1,37 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { appendTranscriptEvents, stripTrailingPartials } from '../src/util/transcript-append.js';
-function ev(type, text) {
-    return { type, text };
-}
-describe('transcript-append', () => {
-    it('replaces the last partial when another partial arrives', () => {
-        const next = appendTranscriptEvents([], [ev('partial', 'a')]);
-        expect(next).toEqual([ev('partial', 'a')]);
-        const next2 = appendTranscriptEvents(next, [ev('partial', 'ab')]);
-        expect(next2).toEqual([ev('partial', 'ab')]);
-    });
-    it('strips trailing partials before a non-partial event', () => {
-        const base = appendTranscriptEvents([], [ev('partial', 'streaming')]);
-        const next = appendTranscriptEvents(base, [ev('assistant', 'Final answer.')]);
-        expect(next.map((e) => e.type)).toEqual(['assistant']);
-        expect(next[0]?.text).toBe('Final answer.');
-    });
-    it('stripTrailingPartials removes only trailing partials', () => {
-        const events = [
-            ev('init', 'init'),
-            ev('partial', 'x'),
-            ev('assistant', 'done'),
-            ev('partial', 'orphan'),
-        ];
-        expect(stripTrailingPartials(events).map((e) => e.type)).toEqual([
-            'init',
-            'partial',
-            'assistant',
-        ]);
-    });
-    it('appends multiple incoming events in order with partial rules', () => {
-        const batch = appendTranscriptEvents([ev('init', 'init')], [ev('partial', 'p1'), ev('partial', 'p2'), ev('user', 'tool output')]);
-        expect(batch.map((e) => e.type)).toEqual(['init', 'user']);
-        expect(batch[1]?.text).toBe('tool output');
-    });
-});

package/dist/test/transcript-store.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/transcript-store.test.js

@@ -1,50 +0,0 @@
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import { describe, expect, it, beforeEach, afterEach } from 'vitest';
-import { TranscriptStore } from '../src/state/transcript-store.js';
-function ev(type, text) {
-    return { type, text };
-}
-describe('TranscriptStore', () => {
-    const testDir = path.join(process.cwd(), '.test-transcript-store-' + process.pid);
-    let store;
-    beforeEach(async () => {
-        await fs.mkdir(testDir, { recursive: true });
-        store = new TranscriptStore('.claude-manager');
-    });
-    afterEach(async () => {
-        await fs.rm(testDir, { recursive: true, force: true });
-    });
-    it('returns empty array for nonexistent session', async () => {
-        const events = await store.readEvents(testDir, 'nonexistent');
-        expect(events).toEqual([]);
-    });
-    it('appends and reads events', async () => {
-        await store.appendEvents(testDir, 'ses_1', [ev('init', 'init'), ev('assistant', 'Hello.')]);
-        const events = await store.readEvents(testDir, 'ses_1');
-        expect(events).toEqual([ev('init', 'init'), ev('assistant', 'Hello.')]);
-    });
-    it('accumulates events across multiple appends', async () => {
-        await store.appendEvents(testDir, 'ses_2', [
-            ev('init', 'init'),
-            ev('assistant', 'First response.'),
-        ]);
-        await store.appendEvents(testDir, 'ses_2', [
-            ev('user', 'Follow-up question'),
-            ev('assistant', 'Second response.'),
-        ]);
-        const events = await store.readEvents(testDir, 'ses_2');
-        expect(events.map((e) => e.type)).toEqual(['init', 'assistant', 'user', 'assistant']);
-        expect(events[3].text).toBe('Second response.');
-    });
-    it('strips trailing partials before persisting', async () => {
-        await store.appendEvents(testDir, 'ses_3', [ev('init', 'init'), ev('partial', 'streaming...')]);
-        const events = await store.readEvents(testDir, 'ses_3');
-        expect(events).toEqual([ev('init', 'init')]);
-    });
-    it('skips write when newEvents is empty', async () => {
-        await store.appendEvents(testDir, 'ses_4', []);
-        const events = await store.readEvents(testDir, 'ses_4');
-        expect(events).toEqual([]);
-    });
-});

package/dist/test/undo-propagation.test.d.ts

@@ -1 +0,0 @@
-export {};