@doingdev/opencode-claude-manager-plugin 0.1.35 → 0.1.43

package/dist/test/session-controller.test.js

@@ -0,0 +1,149 @@
+import { describe, expect, it, vi } from 'vitest';
+import { SessionController } from '../src/manager/session-controller.js';
+import { ContextTracker } from '../src/manager/context-tracker.js';
+function createMockAdapter(results = [{}]) {
+    let callIndex = 0;
+    return {
+        runSession: vi.fn(async () => {
+            const base = {
+                sessionId: 'ses_test',
+                events: [],
+                finalText: 'Done.',
+                turns: 1,
+                totalCostUsd: 0.01,
+                inputTokens: 10_000,
+                outputTokens: 500,
+                contextWindowSize: 200_000,
+            };
+            const overrides = results[callIndex] ?? {};
+            callIndex++;
+            return { ...base, ...overrides };
+        }),
+    };
+}
+describe('SessionController', () => {
+    it('creates a new session on first sendMessage', async () => {
+        const adapter = createMockAdapter();
+        const tracker = new ContextTracker();
+        const controller = new SessionController(adapter, tracker, 'test prompt');
+        expect(controller.isActive).toBe(false);
+        const result = await controller.sendMessage('/tmp', 'hello');
+        expect(controller.isActive).toBe(true);
+        expect(controller.sessionId).toBe('ses_test');
+        expect(result.finalText).toBe('Done.');
+        // Verify system prompt was used (no resume)
+        const call = adapter.runSession.mock.calls[0][0];
+        expect(call.systemPrompt).toBe('test prompt');
+        expect(call.resumeSessionId).toBeUndefined();
+    });
+    it('sends settingSources as user-only', async () => {
+        const adapter = createMockAdapter();
+        const tracker = new ContextTracker();
+        const controller = new SessionController(adapter, tracker, 'test');
+        await controller.sendMessage('/tmp', 'hello');
+        const call = adapter.runSession.mock.calls[0][0];
+        expect(call.settingSources).toEqual(['user']);
+    });
+    it('resumes session on subsequent sends', async () => {
+        const adapter = createMockAdapter([{}, {}]);
+        const tracker = new ContextTracker();
+        const controller = new SessionController(adapter, tracker, 'test prompt');
+        await controller.sendMessage('/tmp', 'first');
+        await controller.sendMessage('/tmp', 'second');
+        const secondCall = adapter.runSession.mock.calls[1][0];
+        expect(secondCall.resumeSessionId).toBe('ses_test');
+        expect(secondCall.systemPrompt).toBeUndefined();
+    });
+    it('updates context tracker on each message', async () => {
+        const adapter = createMockAdapter([{ turns: 3, totalCostUsd: 0.05, inputTokens: 50_000 }]);
+        const tracker = new ContextTracker();
+        const controller = new SessionController(adapter, tracker, 'test');
+        await controller.sendMessage('/tmp', 'task');
+        const snap = controller.getContextSnapshot();
+        expect(snap.totalTurns).toBe(3);
+        expect(snap.totalCostUsd).toBe(0.05);
+        expect(snap.latestInputTokens).toBe(50_000);
+        expect(snap.estimatedContextPercent).toBe(25);
+    });
+    it('clears session and resets context', async () => {
+        const adapter = createMockAdapter();
+        const tracker = new ContextTracker();
+        const controller = new SessionController(adapter, tracker, 'test');
+        await controller.sendMessage('/tmp', 'task');
+        expect(controller.isActive).toBe(true);
+        const clearedId = await controller.clearSession('/tmp');
+        expect(clearedId).toBe('ses_test');
+        expect(controller.isActive).toBe(false);
+        expect(controller.sessionId).toBeNull();
+        const snap = controller.getContextSnapshot();
+        expect(snap.totalTurns).toBe(0);
+        expect(snap.sessionId).toBeNull();
+    });
+    it('sends /compact to current session', async () => {
+        const adapter = createMockAdapter([{}, {}]);
+        const tracker = new ContextTracker();
+        const controller = new SessionController(adapter, tracker, 'test');
+        await controller.sendMessage('/tmp', 'task');
+        await controller.compactSession('/tmp');
+        const compactCall = adapter.runSession.mock.calls[1][0];
+        expect(compactCall.prompt).toBe('/compact');
+        expect(compactCall.resumeSessionId).toBe('ses_test');
+    });
+    it('throws when compacting without active session', async () => {
+        const adapter = createMockAdapter();
+        const tracker = new ContextTracker();
+        const controller = new SessionController(adapter, tracker, 'test');
+        await expect(controller.compactSession('/tmp')).rejects.toThrow('No active session to compact');
+    });
+    it('threads effort through to the SDK input', async () => {
+        const adapter = createMockAdapter();
+        const tracker = new ContextTracker();
+        const controller = new SessionController(adapter, tracker, 'test');
+        await controller.sendMessage('/tmp', 'hard task', { effort: 'max' });
+        const call = adapter.runSession.mock.calls[0][0];
+        expect(call.effort).toBe('max');
+    });
+    describe('plan/free mode', () => {
+        const modePrefixes = {
+            plan: '[PLAN MODE] Read-only planning.',
+            free: '',
+        };
+        it('defaults to free mode with acceptEdits permissionMode', async () => {
+            const adapter = createMockAdapter();
+            const tracker = new ContextTracker();
+            const controller = new SessionController(adapter, tracker, 'test', modePrefixes);
+            await controller.sendMessage('/tmp', 'do something');
+            const call = adapter.runSession.mock.calls[0][0];
+            expect(call.permissionMode).toBe('acceptEdits');
+            expect(call.prompt).toBe('do something');
+        });
+        it('sets permissionMode to plan and prepends prefix in plan mode', async () => {
+            const adapter = createMockAdapter();
+            const tracker = new ContextTracker();
+            const controller = new SessionController(adapter, tracker, 'test', modePrefixes);
+            await controller.sendMessage('/tmp', 'analyze this', { mode: 'plan' });
+            const call = adapter.runSession.mock.calls[0][0];
+            expect(call.permissionMode).toBe('plan');
+            expect(call.prompt).toBe('[PLAN MODE] Read-only planning.\n\nanalyze this');
+        });
+        it('explicit free mode uses acceptEdits and no prefix', async () => {
+            const adapter = createMockAdapter();
+            const tracker = new ContextTracker();
+            const controller = new SessionController(adapter, tracker, 'test', modePrefixes);
+            await controller.sendMessage('/tmp', 'build it', { mode: 'free' });
+            const call = adapter.runSession.mock.calls[0][0];
+            expect(call.permissionMode).toBe('acceptEdits');
+            expect(call.prompt).toBe('build it');
+        });
+        it('works without modePrefixes constructor arg (backward compat)', async () => {
+            const adapter = createMockAdapter();
+            const tracker = new ContextTracker();
+            const controller = new SessionController(adapter, tracker, 'test');
+            await controller.sendMessage('/tmp', 'hello', { mode: 'plan' });
+            const call = adapter.runSession.mock.calls[0][0];
+            expect(call.permissionMode).toBe('plan');
+            // Empty prefix defaults — prompt should be unchanged
+            expect(call.prompt).toBe('hello');
+        });
+    });
+});

package/dist/test/session-live-tailer.test.d.ts

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

package/dist/test/session-live-tailer.test.js

@@ -0,0 +1,313 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync, appendFileSync } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { existsSync, readdirSync } from 'node:fs';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { SessionLiveTailer } from '../src/claude/session-live-tailer.js';
+// ── Helpers ─────────────────────────────────────────────────────────────
+let tmpDir;
+let projectsDir;
+function sessionDir(projectName) {
+    const dir = path.join(projectsDir, projectName, 'sessions');
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function writeSession(projectName, sessionId, lines) {
+    const dir = sessionDir(projectName);
+    const filePath = path.join(dir, `${sessionId}.jsonl`);
+    writeFileSync(filePath, lines.join('\n') + '\n', 'utf8');
+    return filePath;
+}
+/**
+ * Build a tailer that looks in our temp dir instead of ~/.claude/projects.
+ * We override `findSessionFile` to search the temp projects dir.
+ */
+function createTailer() {
+    const tailer = new SessionLiveTailer();
+    // Patch the internal discovery to use our temp dir.
+    tailer.findSessionFile = (sessionId, cwd) => {
+        if (!existsSync(projectsDir))
+            return null;
+        // Fast-path: sanitised cwd
+        if (cwd) {
+            const sanitised = cwd.replace(/\//g, '-');
+            const candidate = path.join(projectsDir, sanitised, 'sessions', `${sessionId}.jsonl`);
+            if (existsSync(candidate))
+                return candidate;
+        }
+        // Scan all project directories
+        try {
+            for (const entry of readdirSync(projectsDir, { withFileTypes: true })) {
+                if (!entry.isDirectory())
+                    continue;
+                const candidate = path.join(projectsDir, entry.name, 'sessions', `${sessionId}.jsonl`);
+                if (existsSync(candidate))
+                    return candidate;
+            }
+        }
+        catch {
+            // ignore
+        }
+        return null;
+    };
+    return tailer;
+}
+// ── Setup / teardown ────────────────────────────────────────────────────
+beforeEach(() => {
+    tmpDir = mkdtempSync(path.join(os.tmpdir(), 'live-tailer-test-'));
+    projectsDir = path.join(tmpDir, '.claude', 'projects');
+    mkdirSync(projectsDir, { recursive: true });
+});
+afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+});
+// ── Tests ───────────────────────────────────────────────────────────────
+describe('SessionLiveTailer', () => {
+    describe('findSessionFile', () => {
+        it('finds a session file by scanning project directories', () => {
+            writeSession('my-project', 'ses_abc', [JSON.stringify({ type: 'system', subtype: 'init' })]);
+            const tailer = createTailer();
+            const found = tailer.findSessionFile('ses_abc');
+            expect(found).not.toBeNull();
+            expect(found).toContain('ses_abc.jsonl');
+        });
+        it('returns null when session does not exist', () => {
+            const tailer = createTailer();
+            expect(tailer.findSessionFile('ses_nonexistent')).toBeNull();
+        });
+        it('prefers sanitised cwd fast-path when cwd is provided', () => {
+            // Create two projects with the same session ID
+            writeSession('-home-user-proj', 'ses_dup', [
+                JSON.stringify({ type: 'system', data: 'fast-path' }),
+            ]);
+            writeSession('other-project', 'ses_dup', [
+                JSON.stringify({ type: 'system', data: 'scan-path' }),
+            ]);
+            const tailer = createTailer();
+            const found = tailer.findSessionFile('ses_dup', '/home/user/proj');
+            expect(found).not.toBeNull();
+            expect(found).toContain('-home-user-proj');
+        });
+    });
+    describe('sessionFileExists', () => {
+        it('returns true when the file exists', () => {
+            writeSession('proj', 'ses_exists', [JSON.stringify({ type: 'system' })]);
+            const tailer = createTailer();
+            expect(tailer.sessionFileExists('ses_exists')).toBe(true);
+        });
+        it('returns false when the file does not exist', () => {
+            const tailer = createTailer();
+            expect(tailer.sessionFileExists('ses_missing')).toBe(false);
+        });
+    });
+    describe('getLastLines', () => {
+        it('returns the last N lines from a JSONL file', async () => {
+            const lines = Array.from({ length: 20 }, (_, i) => JSON.stringify({ type: 'line', index: i }));
+            writeSession('proj', 'ses_lines', lines);
+            const tailer = createTailer();
+            const result = await tailer.getLastLines('ses_lines', undefined, 5);
+            expect(result).toHaveLength(5);
+            expect(JSON.parse(result[0])).toMatchObject({ index: 15 });
+            expect(JSON.parse(result[4])).toMatchObject({ index: 19 });
+        });
+        it('returns all lines when file has fewer than N lines', async () => {
+            writeSession('proj', 'ses_short', [
+                JSON.stringify({ type: 'a' }),
+                JSON.stringify({ type: 'b' }),
+            ]);
+            const tailer = createTailer();
+            const result = await tailer.getLastLines('ses_short', undefined, 10);
+            expect(result).toHaveLength(2);
+        });
+        it('returns empty array when session file not found', async () => {
+            const tailer = createTailer();
+            const result = await tailer.getLastLines('ses_ghost', undefined, 5);
+            expect(result).toEqual([]);
+        });
+    });
+    describe('getToolOutputPreview', () => {
+        it('extracts tool_result from user messages (pattern 1)', async () => {
+            const lines = [
+                JSON.stringify({
+                    type: 'assistant',
+                    message: { content: [{ type: 'text', text: 'Searching...' }] },
+                }),
+                JSON.stringify({
+                    type: 'user',
+                    message: {
+                        content: [
+                            {
+                                type: 'tool_result',
+                                tool_use_id: 'toolu_grep_1',
+                                content: 'src/main.ts:42: const result = await fetch(url);',
+                                is_error: false,
+                            },
+                        ],
+                    },
+                }),
+                JSON.stringify({
+                    type: 'assistant',
+                    message: { content: [{ type: 'text', text: 'Found the match.' }] },
+                }),
+            ];
+            writeSession('proj', 'ses_tool', lines);
+            const tailer = createTailer();
+            const previews = await tailer.getToolOutputPreview('ses_tool', undefined, 5);
+            expect(previews).toHaveLength(1);
+            expect(previews[0]).toMatchObject({
+                toolUseId: 'toolu_grep_1',
+                content: 'src/main.ts:42: const result = await fetch(url);',
+                isError: false,
+            });
+        });
+        it('extracts direct tool_result records (pattern 2)', async () => {
+            const lines = [
+                JSON.stringify({
+                    type: 'tool_result',
+                    tool_use_id: 'toolu_bash_1',
+                    content: 'npm test: 42 passed, 0 failed',
+                    is_error: false,
+                }),
+            ];
+            writeSession('proj', 'ses_direct', lines);
+            const tailer = createTailer();
+            const previews = await tailer.getToolOutputPreview('ses_direct', undefined, 5);
+            expect(previews).toHaveLength(1);
+            expect(previews[0]).toMatchObject({
+                toolUseId: 'toolu_bash_1',
+                content: 'npm test: 42 passed, 0 failed',
+                isError: false,
+            });
+        });
+        it('handles error tool results', async () => {
+            const lines = [
+                JSON.stringify({
+                    type: 'tool_result',
+                    tool_use_id: 'toolu_err',
+                    content: 'ENOENT: no such file',
+                    is_error: true,
+                }),
+            ];
+            writeSession('proj', 'ses_err', lines);
+            const tailer = createTailer();
+            const previews = await tailer.getToolOutputPreview('ses_err', undefined, 5);
+            expect(previews).toHaveLength(1);
+            expect(previews[0].isError).toBe(true);
+        });
+        it('limits results to maxEntries', async () => {
+            const lines = Array.from({ length: 10 }, (_, i) => JSON.stringify({
+                type: 'tool_result',
+                tool_use_id: `toolu_${i}`,
+                content: `result ${i}`,
+                is_error: false,
+            }));
+            writeSession('proj', 'ses_limit', lines);
+            const tailer = createTailer();
+            const previews = await tailer.getToolOutputPreview('ses_limit', undefined, 3);
+            expect(previews).toHaveLength(3);
+            // Should return the last 3
+            expect(previews[0].toolUseId).toBe('toolu_7');
+            expect(previews[2].toolUseId).toBe('toolu_9');
+        });
+        it('skips non-tool-result lines', async () => {
+            const lines = [
+                JSON.stringify({ type: 'system', subtype: 'init' }),
+                JSON.stringify({
+                    type: 'assistant',
+                    message: { content: [{ type: 'text', text: 'hi' }] },
+                }),
+                JSON.stringify({
+                    type: 'tool_result',
+                    tool_use_id: 'toolu_1',
+                    content: 'output',
+                    is_error: false,
+                }),
+                JSON.stringify({ type: 'result', subtype: 'success', result: 'Done' }),
+            ];
+            writeSession('proj', 'ses_mixed', lines);
+            const tailer = createTailer();
+            const previews = await tailer.getToolOutputPreview('ses_mixed', undefined, 10);
+            expect(previews).toHaveLength(1);
+            expect(previews[0].toolUseId).toBe('toolu_1');
+        });
+        it('returns empty array when session not found', async () => {
+            const tailer = createTailer();
+            const previews = await tailer.getToolOutputPreview('ses_nope', undefined);
+            expect(previews).toEqual([]);
+        });
+        it('handles non-string content by JSON-stringifying it', async () => {
+            const lines = [
+                JSON.stringify({
+                    type: 'tool_result',
+                    tool_use_id: 'toolu_obj',
+                    content: [{ type: 'text', text: 'structured output' }],
+                    is_error: false,
+                }),
+            ];
+            writeSession('proj', 'ses_obj', lines);
+            const tailer = createTailer();
+            const previews = await tailer.getToolOutputPreview('ses_obj', undefined, 5);
+            expect(previews).toHaveLength(1);
+            expect(previews[0].content).toBe(JSON.stringify([{ type: 'text', text: 'structured output' }]));
+        });
+    });
+    describe('startTailing', () => {
+        it('emits error event when session file not found', () => {
+            const tailer = createTailer();
+            const events = [];
+            const stop = tailer.startTailing('ses_missing', undefined, (e) => events.push(e));
+            expect(events).toHaveLength(1);
+            expect(events[0].type).toBe('error');
+            expect(events[0].error).toContain('ses_missing');
+            stop();
+        });
+        it('picks up new lines appended after tailing starts', async () => {
+            // Write initial content.
+            const filePath = writeSession('proj', 'ses_tail', [
+                JSON.stringify({ type: 'system', subtype: 'init' }),
+            ]);
+            const tailer = createTailer();
+            const events = [];
+            // Start tailing (offset begins at end of existing content).
+            const stop = tailer.startTailing('ses_tail', undefined, (e) => events.push(e), 50);
+            // Append a new line after a short delay.
+            await sleep(80);
+            appendFileSync(filePath, JSON.stringify({
+                type: 'tool_result',
+                tool_use_id: 'toolu_new',
+                content: 'hello',
+            }) + '\n');
+            // Wait for the poll to pick it up.
+            await sleep(200);
+            stop();
+            const lineEvents = events.filter((e) => e.type === 'line');
+            expect(lineEvents.length).toBeGreaterThanOrEqual(1);
+            expect(lineEvents[0].data).toMatchObject({
+                type: 'tool_result',
+                tool_use_id: 'toolu_new',
+            });
+        });
+        it('stopTailing clears the interval', () => {
+            writeSession('proj', 'ses_stop', [JSON.stringify({ type: 'system' })]);
+            const tailer = createTailer();
+            const stop = tailer.startTailing('ses_stop', undefined, () => { }, 50);
+            // Stop should not throw and should be idempotent.
+            stop();
+            stop();
+            tailer.stopTailing('ses_stop');
+        });
+        it('stopAll clears all active tails', () => {
+            writeSession('proj', 'ses_a', [JSON.stringify({ type: 'system' })]);
+            writeSession('proj', 'ses_b', [JSON.stringify({ type: 'system' })]);
+            const tailer = createTailer();
+            tailer.startTailing('ses_a', undefined, () => { }, 50);
+            tailer.startTailing('ses_b', undefined, () => { }, 50);
+            tailer.stopAll();
+            // Verify idempotent — should not throw.
+            tailer.stopAll();
+        });
+    });
+});
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/test/tool-approval-manager.test.d.ts

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