@ai-devkit/agent-manager 0.15.0 → 0.17.0

package/src/__tests__/terminal/TmuxManager.test.ts

@@ -0,0 +1,175 @@
+import { execFile } from 'child_process';
+import type { MockedFunction } from 'vitest';
+import { TmuxManager } from '../../terminal/TmuxManager.js';
+
+vi.mock('child_process', () => ({
+    execFile: vi.fn(),
+}));
+
+type ExecFileCb = (err: Error | null, result?: { stdout: string; stderr: string }) => void;
+const mockedExecFile = execFile as unknown as MockedFunction<
+    (cmd: string, args: string[], cb: ExecFileCb) => void
+>;
+
+/** Drive the promisified execFile mock with a per-call handler. */
+function setExecFileHandler(handler: (cmd: string, args: string[]) => string | Error) {
+    mockedExecFile.mockImplementation((_cmd, _args, cb) => {
+        const result = handler(_cmd, _args);
+        if (result instanceof Error) cb(result);
+        else cb(null, { stdout: result, stderr: '' });
+    });
+}
+
+describe('TmuxManager', () => {
+    let tmux: TmuxManager;
+
+    beforeEach(() => {
+        tmux = new TmuxManager();
+        mockedExecFile.mockReset();
+    });
+
+    describe('isAvailable', () => {
+        it('returns true when `tmux -V` succeeds', async () => {
+            setExecFileHandler(() => 'tmux 3.4');
+            expect(await tmux.isAvailable()).toBe(true);
+        });
+
+        it('returns false when tmux is missing', async () => {
+            setExecFileHandler(() => new Error('ENOENT'));
+            expect(await tmux.isAvailable()).toBe(false);
+        });
+    });
+
+    describe('sessionExists', () => {
+        it('returns true when has-session succeeds', async () => {
+            setExecFileHandler(() => '');
+            expect(await tmux.sessionExists('foo')).toBe(true);
+        });
+
+        it('returns false when has-session fails', async () => {
+            setExecFileHandler(() => new Error('no session'));
+            expect(await tmux.sessionExists('foo')).toBe(false);
+        });
+    });
+
+    describe('createSession', () => {
+        it('issues `tmux new-session -d -s <name> -c <cwd>`', async () => {
+            setExecFileHandler(() => '');
+            await tmux.createSession('foo', '/work');
+            expect(mockedExecFile).toHaveBeenCalledWith(
+                'tmux',
+                ['new-session', '-d', '-s', 'foo', '-c', '/work'],
+                expect.any(Function),
+            );
+        });
+    });
+
+    describe('sendKeys', () => {
+        it('appends Enter so the command runs', async () => {
+            setExecFileHandler(() => '');
+            await tmux.sendKeys('foo', 'claude');
+            expect(mockedExecFile).toHaveBeenCalledWith(
+                'tmux',
+                ['send-keys', '-t', 'foo', 'claude', 'Enter'],
+                expect.any(Function),
+            );
+        });
+    });
+
+    describe('killSession', () => {
+        it('swallows errors when session is already gone', async () => {
+            setExecFileHandler(() => new Error("can't find session"));
+            await expect(tmux.killSession('foo')).resolves.toBeUndefined();
+        });
+    });
+
+    describe('findAgentPid', () => {
+        const matchesClaude = (cmd: string) => cmd.split(/\s+/)[0]?.endsWith('claude') ?? false;
+
+        it('returns null when the session has no pane', async () => {
+            setExecFileHandler((cmd, args) => {
+                if (args[0] === 'list-panes') return new Error('no session');
+                return '';
+            });
+            expect(await tmux.findAgentPid('foo', matchesClaude)).toBeNull();
+        });
+
+        it('returns null when no descendant matches', async () => {
+            // pane PID 100; child 200 is "node /unrelated" — no match
+            setExecFileHandler((cmd, args) => {
+                if (cmd === 'tmux' && args[0] === 'list-panes') return '100\n';
+                if (cmd === 'pgrep' && args[1] === '100') return '200\n';
+                if (cmd === 'pgrep') return new Error('no children');
+                if (cmd === 'ps' && args[1] === '200') return 'node /unrelated';
+                return '';
+            });
+            expect(await tmux.findAgentPid('foo', matchesClaude)).toBeNull();
+        });
+
+        it('returns the matching descendant when found', async () => {
+            // pane 100 → child 200 (claude) — no grandchildren
+            setExecFileHandler((cmd, args) => {
+                if (cmd === 'tmux') return '100\n';
+                if (cmd === 'pgrep' && args[1] === '100') return '200\n';
+                if (cmd === 'pgrep') return new Error('no children');
+                if (cmd === 'ps' && args[1] === '200') return 'claude';
+                return '';
+            });
+            expect(await tmux.findAgentPid('foo', matchesClaude)).toBe(200);
+        });
+
+        it('prefers the deepest match (wrapper case)', async () => {
+            // pane 100 → 200 (claude wrapper, matches) → 300 (claude, matches, deeper)
+            setExecFileHandler((cmd, args) => {
+                if (cmd === 'tmux') return '100\n';
+                if (cmd === 'pgrep' && args[1] === '100') return '200\n';
+                if (cmd === 'pgrep' && args[1] === '200') return '300\n';
+                if (cmd === 'pgrep') return new Error('no children');
+                if (cmd === 'ps' && args[1] === '200') return '/usr/local/bin/claude';
+                if (cmd === 'ps' && args[1] === '300') return '/usr/local/lib/claude';
+                return '';
+            });
+            expect(await tmux.findAgentPid('foo', matchesClaude)).toBe(300);
+        });
+
+        it('skips non-matching subprocesses (MCP child case)', async () => {
+            // pane 100 → 200 (claude, matches) → 300 (mcp-server, no match)
+            setExecFileHandler((cmd, args) => {
+                if (cmd === 'tmux') return '100\n';
+                if (cmd === 'pgrep' && args[1] === '100') return '200\n';
+                if (cmd === 'pgrep' && args[1] === '200') return '300\n';
+                if (cmd === 'pgrep') return new Error('no children');
+                if (cmd === 'ps' && args[1] === '200') return 'claude';
+                if (cmd === 'ps' && args[1] === '300') return 'node mcp-server.js';
+                return '';
+            });
+            expect(await tmux.findAgentPid('foo', matchesClaude)).toBe(200);
+        });
+
+        it('handles the gemini Node-script shape via a token-scan matcher', async () => {
+            const matchesGemini = (cmd: string) =>
+                cmd.split(/\s+/).some((t) => t.endsWith('/gemini') || t === 'gemini');
+            setExecFileHandler((cmd, args) => {
+                if (cmd === 'tmux') return '100\n';
+                if (cmd === 'pgrep' && args[1] === '100') return '200\n';
+                if (cmd === 'pgrep') return new Error('no children');
+                if (cmd === 'ps' && args[1] === '200') return 'node /opt/homebrew/bin/gemini --foo';
+                return '';
+            });
+            expect(await tmux.findAgentPid('foo', matchesGemini)).toBe(200);
+        });
+
+        it('handles multiple children at the same level', async () => {
+            // pane 100 → [200 (nope), 201 (claude)]
+            setExecFileHandler((cmd, args) => {
+                if (cmd === 'tmux') return '100\n';
+                if (cmd === 'pgrep' && args[1] === '100') return '200\n201\n';
+                if (cmd === 'pgrep') return new Error('no children');
+                if (cmd === 'ps' && args[1] === '200') return 'bash';
+                if (cmd === 'ps' && args[1] === '201') return 'claude';
+                return '';
+            });
+            expect(await tmux.findAgentPid('foo', matchesClaude)).toBe(201);
+        });
+    });
+});

package/src/__tests__/utils/AgentRegistry.test.ts

@@ -0,0 +1,223 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { AgentRegistry, RenameNotFoundError, RenameConflictError, type RegistryEntry } from '../../utils/AgentRegistry.js';
+
+function makeEntry(over: Partial<RegistryEntry> = {}): RegistryEntry {
+    return {
+        name: 'agent1',
+        type: 'claude',
+        pid: process.pid,
+        tmuxSession: 'agent1',
+        cwd: '/tmp',
+        startedAt: '2026-05-30T00:00:00.000Z',
+        sessionId: 'sid-1',
+        sessionFilePath: '/tmp/session.jsonl',
+        ...over,
+    };
+}
+
+describe('AgentRegistry', () => {
+    let tmpDir: string;
+    let regPath: string;
+    let registry: AgentRegistry;
+
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-registry-'));
+        regPath = path.join(tmpDir, 'nested', 'agents.json');
+        registry = new AgentRegistry(regPath);
+    });
+
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    describe('register', () => {
+        it('creates the file and parent directory if missing', () => {
+            registry.register(makeEntry());
+            expect(fs.existsSync(regPath)).toBe(true);
+            const parsed = JSON.parse(fs.readFileSync(regPath, 'utf8'));
+            expect(parsed.entries).toHaveLength(1);
+            expect(parsed.entries[0].name).toBe('agent1');
+        });
+
+        it('appends a new entry when name is unique', () => {
+            registry.register(makeEntry({ name: 'a' }));
+            registry.register(makeEntry({ name: 'b' }));
+            expect(registry.list()).toHaveLength(2);
+        });
+
+        it('upserts in place when name already exists', () => {
+            registry.register(makeEntry({ name: 'a', pid: 100 }));
+            registry.register(makeEntry({ name: 'a', pid: 200 }));
+            const all = registry.list();
+            expect(all).toHaveLength(1);
+            expect(all[0].pid).toBe(200);
+        });
+
+        it('writes atomically (no leftover .tmp on success)', () => {
+            registry.register(makeEntry());
+            expect(fs.existsSync(`${regPath}.tmp`)).toBe(false);
+        });
+
+        it('persists session fields', () => {
+            registry.register(makeEntry({ sessionId: 'sid-xyz', sessionFilePath: '/foo/bar.jsonl' }));
+            const saved = registry.list()[0];
+            expect(saved.sessionId).toBe('sid-xyz');
+            expect(saved.sessionFilePath).toBe('/foo/bar.jsonl');
+        });
+
+        it('preserves existing tmuxSession when incoming is empty string', () => {
+            registry.register(makeEntry({ name: 'a', tmuxSession: 'pinned' }));
+            registry.register(makeEntry({ name: 'a', tmuxSession: '', pid: 999 }));
+            const saved = registry.lookup('a');
+            expect(saved?.tmuxSession).toBe('pinned');
+            expect(saved?.pid).toBe(999);
+        });
+
+        it('replaces tmuxSession when incoming is non-empty', () => {
+            registry.register(makeEntry({ name: 'a', tmuxSession: 'old' }));
+            registry.register(makeEntry({ name: 'a', tmuxSession: 'new' }));
+            expect(registry.lookup('a')?.tmuxSession).toBe('new');
+        });
+    });
+
+    describe('registerBatch', () => {
+        it('is a no-op on empty array', () => {
+            registry.registerBatch([]);
+            expect(fs.existsSync(regPath)).toBe(false);
+        });
+
+        it('upserts multiple entries with a single write', () => {
+            const writeSpy = vi.spyOn(fs, 'writeFileSync');
+            registry.registerBatch([
+                makeEntry({ name: 'a' }),
+                makeEntry({ name: 'b' }),
+                makeEntry({ name: 'c' }),
+            ]);
+            expect(writeSpy).toHaveBeenCalledTimes(1);
+            writeSpy.mockRestore();
+            expect(registry.list()).toHaveLength(3);
+        });
+
+        it('applies the tmuxSession merge per entry', () => {
+            registry.register(makeEntry({ name: 'a', tmuxSession: 'pinned' }));
+            registry.registerBatch([
+                makeEntry({ name: 'a', tmuxSession: '', pid: 7 }),
+                makeEntry({ name: 'b', tmuxSession: '' }),
+            ]);
+            expect(registry.lookup('a')?.tmuxSession).toBe('pinned');
+            expect(registry.lookup('a')?.pid).toBe(7);
+            expect(registry.lookup('b')?.tmuxSession).toBe('');
+        });
+    });
+
+    describe('lookup', () => {
+        it('returns null when name not found', () => {
+            expect(registry.lookup('missing')).toBeNull();
+        });
+
+        it('returns the entry when name matches', () => {
+            registry.register(makeEntry({ name: 'a' }));
+            expect(registry.lookup('a')?.name).toBe('a');
+        });
+    });
+
+    describe('list', () => {
+        it('returns empty array when file does not exist', () => {
+            expect(registry.list()).toEqual([]);
+        });
+
+        it('returns empty array when file is malformed', () => {
+            fs.mkdirSync(path.dirname(regPath), { recursive: true });
+            fs.writeFileSync(regPath, 'not json', 'utf8');
+            expect(registry.list()).toEqual([]);
+        });
+
+        it('coerces non-array entries to []', () => {
+            fs.mkdirSync(path.dirname(regPath), { recursive: true });
+            fs.writeFileSync(regPath, JSON.stringify({ entries: 'oops' }), 'utf8');
+            expect(registry.list()).toEqual([]);
+        });
+    });
+
+    describe('isAlive', () => {
+        it('returns true for the current process', () => {
+            expect(registry.isAlive(makeEntry({ pid: process.pid }))).toBe(true);
+        });
+
+        it('returns false for a PID that does not exist', () => {
+            expect(registry.isAlive(makeEntry({ pid: 999999 }))).toBe(false);
+        });
+    });
+
+    describe('prune', () => {
+        it('removes entries whose PIDs are dead', () => {
+            registry.register(makeEntry({ name: 'alive', pid: process.pid }));
+            registry.register(makeEntry({ name: 'dead', pid: 999999 }));
+            registry.prune();
+            const remaining = registry.list();
+            expect(remaining).toHaveLength(1);
+            expect(remaining[0].name).toBe('alive');
+        });
+
+        it('is a no-op when all entries are alive', () => {
+            registry.register(makeEntry({ pid: process.pid }));
+            const before = fs.readFileSync(regPath, 'utf8');
+            registry.prune();
+            const after = fs.readFileSync(regPath, 'utf8');
+            expect(after).toBe(before);
+        });
+
+        it('does nothing when file is missing', () => {
+            expect(() => registry.prune()).not.toThrow();
+        });
+    });
+
+    describe('default()', () => {
+        it('returns a singleton instance', () => {
+            expect(AgentRegistry.default()).toBe(AgentRegistry.default());
+        });
+    });
+
+    describe('rename', () => {
+        it('updates the name of an existing entry', () => {
+            registry.register(makeEntry({ name: 'old-name', pid: process.pid }));
+            registry.rename('old-name', 'new-name');
+            expect(registry.lookup('new-name')?.name).toBe('new-name');
+            expect(registry.lookup('old-name')).toBeNull();
+        });
+
+        it('preserves all other fields on the renamed entry', () => {
+            registry.register(makeEntry({ name: 'old-name', pid: process.pid, tmuxSession: 'old-name', cwd: '/my/cwd' }));
+            registry.rename('old-name', 'new-name');
+            const entry = registry.lookup('new-name');
+            expect(entry?.tmuxSession).toBe('old-name');
+            expect(entry?.cwd).toBe('/my/cwd');
+            expect(entry?.pid).toBe(process.pid);
+        });
+
+        it('throws RenameNotFoundError when current name does not exist', () => {
+            expect(() => registry.rename('ghost', 'new-name')).toThrow(RenameNotFoundError);
+        });
+
+        it('throws RenameConflictError when new name is already in use by a live entry', () => {
+            registry.register(makeEntry({ name: 'agent-a', pid: process.pid }));
+            registry.register(makeEntry({ name: 'agent-b', pid: process.pid }));
+            expect(() => registry.rename('agent-a', 'agent-b')).toThrow(RenameConflictError);
+        });
+
+        it('succeeds when new name exists only as a stale (dead) entry', () => {
+            registry.register(makeEntry({ name: 'agent-a', pid: process.pid }));
+            registry.register(makeEntry({ name: 'agent-b', pid: 999999 }));
+            expect(() => registry.rename('agent-a', 'agent-b')).not.toThrow();
+            expect(registry.lookup('agent-b')?.pid).toBe(process.pid);
+        });
+
+        it('writes atomically (no leftover .tmp on success)', () => {
+            registry.register(makeEntry({ name: 'old-name', pid: process.pid }));
+            registry.rename('old-name', 'new-name');
+            expect(fs.existsSync(`${regPath}.tmp`)).toBe(false);
+        });
+    });
+});

package/src/__tests__/utils/ClaudeSessionParser.test.ts

@@ -193,3 +193,74 @@ describe('ClaudeSessionParser.getConversation — harness tag stripping', () =>
         expect(conv[0].content).toBe('before\n\nafter');
     });
 });
+
+describe('ClaudeSessionParser.readSession — UI-state entries ignored for status', () => {
+    let parser: ClaudeSessionParser;
+    const tempFiles: string[] = [];
+
+    beforeEach(() => {
+        parser = new ClaudeSessionParser();
+    });
+
+    afterEach(() => {
+        for (const f of tempFiles) {
+            try {
+                fs.rmSync(path.dirname(f), { recursive: true, force: true });
+            } catch { /* best effort */ }
+        }
+        tempFiles.length = 0;
+    });
+
+    function writeRawSession(lines: object[]): string {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'parser-status-'));
+        const filePath = path.join(dir, 'session.jsonl');
+        fs.writeFileSync(filePath, lines.map(l => JSON.stringify(l)).join('\n'));
+        tempFiles.push(filePath);
+        return filePath;
+    }
+
+    const uiStateTypes = [
+        'attachment',
+        'permission-mode',
+        'ai-title',
+        'queued_command',
+        'tools_changed',
+        'model_changed',
+        'hook_progress',
+    ];
+
+    for (const uiType of uiStateTypes) {
+        it(`keeps lastEntryType from previous conversation turn when trailing entry is ${uiType}`, () => {
+            const file = writeRawSession([
+                { type: 'user', timestamp: '2026-05-30T06:17:57.189Z', message: { content: 'hello' } },
+                { type: uiType, timestamp: '2026-05-30T06:17:57.201Z' },
+            ]);
+
+            const session = parser.readSession(file, '/test');
+            expect(session?.lastEntryType).toBe('user');
+        });
+    }
+
+    it('keeps lastEntryType from a user turn even with multiple trailing UI-state entries', () => {
+        const file = writeRawSession([
+            { type: 'user', timestamp: '2026-05-30T06:17:57.189Z', message: { content: 'hello' } },
+            { type: 'attachment', timestamp: '2026-05-30T06:17:57.200Z', attachment: { type: 'task_reminder', content: [] } },
+            { type: 'permission-mode', timestamp: '2026-05-30T06:17:57.210Z', permissionMode: 'default' },
+            { type: 'ai-title', timestamp: '2026-05-30T06:17:57.220Z' },
+        ]);
+
+        const session = parser.readSession(file, '/test');
+        expect(session?.lastEntryType).toBe('user');
+    });
+
+    it('keeps lastEntryType from assistant turn when followed by UI-state events', () => {
+        const file = writeRawSession([
+            { type: 'user', timestamp: '2026-05-30T06:17:00.000Z', message: { content: 'go' } },
+            { type: 'assistant', timestamp: '2026-05-30T06:17:01.000Z', message: { content: [{ type: 'text', text: 'done' }] } },
+            { type: 'permission-mode', timestamp: '2026-05-30T06:17:02.000Z', permissionMode: 'default' },
+        ]);
+
+        const session = parser.readSession(file, '/test');
+        expect(session?.lastEntryType).toBe('assistant');
+    });
+});

package/src/adapters/AgentAdapter.ts

@@ -8,7 +8,7 @@
 /**
  * Type of AI agent
  */
-export type AgentType = 'claude' | 'gemini_cli' | 'codex' | 'opencode' | 'other';
+export type AgentType = 'claude' | 'gemini_cli' | 'codex' | 'opencode' | 'copilot' | 'other';
 
 /**
  * Current status of an agent