@ai-devkit/agent-manager 0.15.0 → 0.16.0

package/src/__tests__/AgentManager.test.ts

@@ -3,6 +3,9 @@
  */
 
 
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
 import { AgentManager } from '../AgentManager.js';
 import type {
     AgentAdapter,
@@ -12,6 +15,7 @@ import type {
     SessionSummary,
 } from '../adapters/AgentAdapter.js';
 import { AgentStatus } from '../adapters/AgentAdapter.js';
+import { AgentRegistry, type RegistryEntry } from '../utils/AgentRegistry.js';
 
 // Mock adapter for testing
 class MockAdapter implements AgentAdapter {
@@ -240,6 +244,137 @@ describe('AgentManager', () => {
         });
     });
 
+    describe('listAgents — registry persistence', () => {
+        let tmpDir: string;
+        let regPath: string;
+        let registry: AgentRegistry;
+        let scopedManager: AgentManager;
+
+        beforeEach(() => {
+            tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-manager-'));
+            regPath = path.join(tmpDir, 'agents.json');
+            registry = new AgentRegistry(regPath);
+            scopedManager = new AgentManager(registry);
+        });
+
+        afterEach(() => {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
+        it('persists every detected agent to the registry', async () => {
+            scopedManager.registerAdapter(new MockAdapter('claude', [
+                createMockAgent({
+                    name: 'a',
+                    pid: process.pid,
+                    sessionId: 'sid-a',
+                    sessionFilePath: '/path/a.jsonl',
+                    projectPath: '/cwd/a',
+                }),
+            ]));
+
+            await scopedManager.listAgents();
+
+            const entries = registry.list();
+            expect(entries).toHaveLength(1);
+            expect(entries[0]).toMatchObject({
+                name: 'a',
+                type: 'claude',
+                pid: process.pid,
+                cwd: '/cwd/a',
+                sessionId: 'sid-a',
+                sessionFilePath: '/path/a.jsonl',
+                tmuxSession: '',
+            });
+            expect(entries[0].startedAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+        });
+
+        it('prunes entries for dead pids', async () => {
+            registry.register({
+                name: 'dead',
+                type: 'claude',
+                pid: 999999,
+                tmuxSession: '',
+                cwd: '/cwd/dead',
+                startedAt: '2026-05-30T00:00:00.000Z',
+                sessionId: 'sid-dead',
+                sessionFilePath: '/path/dead.jsonl',
+            });
+
+            scopedManager.registerAdapter(new MockAdapter('claude', [
+                createMockAgent({ name: 'live', pid: process.pid }),
+            ]));
+
+            await scopedManager.listAgents();
+
+            const entries = registry.list();
+            expect(entries.map((e) => e.name)).toEqual(['live']);
+        });
+
+        it('preserves an existing name (e.g. user-set "merry") across cycles', async () => {
+            registry.register({
+                name: 'merry',
+                type: 'claude',
+                pid: process.pid,
+                tmuxSession: 'merry',
+                cwd: '/cwd/merry',
+                startedAt: '2026-05-30T00:00:00.000Z',
+                sessionId: 'sid-merry',
+                sessionFilePath: '/path/merry.jsonl',
+            });
+
+            scopedManager.registerAdapter(new MockAdapter('claude', [
+                createMockAgent({ name: 'default-name', pid: process.pid }),
+            ]));
+
+            const agents = await scopedManager.listAgents();
+
+            expect(agents[0].name).toBe('merry');
+            expect(registry.list()[0].name).toBe('merry');
+            expect(registry.list()[0].tmuxSession).toBe('merry');
+            expect(registry.list()[0].startedAt).toBe('2026-05-30T00:00:00.000Z');
+        });
+
+        it('writes a fresh startedAt for new entries', async () => {
+            const before = new Date().toISOString();
+            scopedManager.registerAdapter(new MockAdapter('claude', [
+                createMockAgent({ name: 'new', pid: process.pid }),
+            ]));
+
+            await scopedManager.listAgents();
+
+            const entry = registry.list()[0];
+            expect(entry.startedAt >= before).toBe(true);
+        });
+
+        it('batches the write — a single registerBatch call per listAgents', async () => {
+            const spy = vi.spyOn(registry, 'registerBatch');
+
+            scopedManager.registerAdapter(new MockAdapter('claude', [
+                createMockAgent({ name: 'a', pid: process.pid }),
+            ]));
+            scopedManager.registerAdapter(new MockAdapter('codex', [
+                createMockAgent({ name: 'b', type: 'codex', pid: process.pid + 1 }),
+            ]));
+
+            await scopedManager.listAgents();
+
+            expect(spy).toHaveBeenCalledTimes(1);
+            expect((spy.mock.calls[0][0] as RegistryEntry[]).map((e) => e.name).sort())
+                .toEqual(['a', 'b']);
+        });
+
+        it('skips registerBatch when no agents detected (still calls prune)', async () => {
+            const writeSpy = vi.spyOn(registry, 'registerBatch');
+            const pruneSpy = vi.spyOn(registry, 'prune');
+
+            scopedManager.registerAdapter(new MockAdapter('claude', []));
+            await scopedManager.listAgents();
+
+            expect(writeSpy).not.toHaveBeenCalled();
+            expect(pruneSpy).toHaveBeenCalledTimes(1);
+        });
+    });
+
     describe('clear', () => {
         it('should remove all adapters', () => {
             manager.registerAdapter(new MockAdapter('claude'));

package/src/__tests__/adapters/ClaudeCodeAdapter.test.ts

@@ -427,8 +427,7 @@ describe('ClaudeCodeAdapter', () => {
 
             const sessionId = 'wait-session';
             const jsonlPath = path.join(projDir, `${sessionId}.jsonl`);
-            // JSONL trails with permission-mode → parser would resolve to UNKNOWN.
-            // PID file's live status must win.
+            // PID file's live status must win over JSONL-derived status.
             fs.writeFileSync(jsonlPath, [
                 JSON.stringify({ type: 'user', timestamp: new Date().toISOString(), cwd: '/project/wait', message: { content: '/reddit-commenter' } }),
                 JSON.stringify({ type: 'permission-mode', timestamp: new Date().toISOString(), permissionMode: 'default' }),

package/src/__tests__/adapters/CodexAdapter.test.ts

@@ -9,6 +9,7 @@ import * as path from 'path';
 import { CodexAdapter } from '../../adapters/CodexAdapter.js';
 import type { ProcessInfo } from '../../adapters/AgentAdapter.js';
 import { AgentStatus } from '../../adapters/AgentAdapter.js';
+import { AgentRegistry, type RegistryEntry } from '../../utils/AgentRegistry.js';
 import { listAgentProcesses, enrichProcesses } from '../../utils/process.js';
 import { batchGetSessionFileBirthtimes } from '../../utils/session.js';
 import type { SessionFile } from '../../utils/session.js';
@@ -249,6 +250,110 @@ describe('CodexAdapter', () => {
         });
     });
 
+    describe('detectAgents — registry cache short-circuit', () => {
+        let tmpDir: string;
+        let regPath: string;
+        let registry: AgentRegistry;
+        let cachedAdapter: CodexAdapter;
+        let sessionFilePath: string;
+
+        function registerEntry(over: Partial<RegistryEntry> = {}): void {
+            registry.register({
+                name: 'codex-100',
+                type: 'codex',
+                pid: 100,
+                tmuxSession: '',
+                cwd: '/repo-a',
+                startedAt: '2026-05-30T00:00:00.000Z',
+                sessionId: 'sess-cached',
+                sessionFilePath,
+                ...over,
+            });
+        }
+
+        beforeEach(() => {
+            tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-cache-'));
+            regPath = path.join(tmpDir, 'agents.json');
+            registry = new AgentRegistry(regPath);
+            cachedAdapter = new CodexAdapter(registry);
+
+            const recentTs = new Date().toISOString();
+            sessionFilePath = path.join(tmpDir, 'sess-cached.jsonl');
+            fs.writeFileSync(sessionFilePath, [
+                JSON.stringify({ type: 'session_meta', payload: { id: 'sess-cached', timestamp: recentTs, cwd: '/repo-a' } }),
+                JSON.stringify({ type: 'event', timestamp: recentTs, payload: { type: 'token_count', message: 'Hello from cache' } }),
+            ].join('\n'));
+        });
+
+        afterEach(() => {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
+        it('short-circuits matching when registry has a valid entry', async () => {
+            registerEntry();
+            const processes: ProcessInfo[] = [
+                { pid: 100, command: 'codex', cwd: '/repo-a', tty: 'ttys001', startTime: new Date() },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+
+            const agents = await cachedAdapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                type: 'codex',
+                pid: 100,
+                sessionId: 'sess-cached',
+                sessionFilePath,
+                summary: 'Hello from cache',
+            });
+            expect(mockedMatchProcessesToSessions).not.toHaveBeenCalled();
+            expect(mockedBatchGetSessionFileBirthtimes).not.toHaveBeenCalled();
+        });
+
+        it('falls through when no registry entry exists for the pid', async () => {
+            const processes: ProcessInfo[] = [
+                { pid: 100, command: 'codex', cwd: '/repo-a', tty: 'ttys001', startTime: new Date() },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+            (cachedAdapter as any).codexSessionsDir = '/nonexistent';
+
+            const agents = await cachedAdapter.detectAgents();
+
+            expect(agents[0].sessionId).toBe('pid-100');
+        });
+
+        it('falls through when registry entry type does not match', async () => {
+            registerEntry({ type: 'claude' });
+            const processes: ProcessInfo[] = [
+                { pid: 100, command: 'codex', cwd: '/repo-a', tty: 'ttys001', startTime: new Date() },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+            (cachedAdapter as any).codexSessionsDir = '/nonexistent';
+
+            const agents = await cachedAdapter.detectAgents();
+
+            expect(agents[0].sessionId).toBe('pid-100');
+            expect(mockedMatchProcessesToSessions).not.toHaveBeenCalled();
+        });
+
+        it('falls through when the cached session file no longer exists', async () => {
+            registerEntry({ sessionFilePath: path.join(tmpDir, 'deleted.jsonl') });
+            const processes: ProcessInfo[] = [
+                { pid: 100, command: 'codex', cwd: '/repo-a', tty: 'ttys001', startTime: new Date() },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+            (cachedAdapter as any).codexSessionsDir = '/nonexistent';
+
+            const agents = await cachedAdapter.detectAgents();
+
+            expect(agents[0].sessionId).toBe('pid-100');
+        });
+    });
+
     describe('discoverSessions', () => {
         let tmpDir: string;
 

package/src/__tests__/adapters/GeminiCliAdapter.test.ts

@@ -10,6 +10,7 @@ import * as path from 'path';
 import { GeminiCliAdapter } from '../../adapters/GeminiCliAdapter.js';
 import type { ProcessInfo } from '../../adapters/AgentAdapter.js';
 import { AgentStatus } from '../../adapters/AgentAdapter.js';
+import { AgentRegistry, type RegistryEntry } from '../../utils/AgentRegistry.js';
 import { listAgentProcesses, enrichProcesses } from '../../utils/process.js';
 import { matchProcessesToSessions, generateAgentName } from '../../utils/matching.js';
 import * as crypto from 'crypto';
@@ -251,6 +252,116 @@ describe('GeminiCliAdapter', () => {
         });
     });
 
+    describe('detectAgents — registry cache short-circuit', () => {
+        let regPath: string;
+        let registry: AgentRegistry;
+        let cachedAdapter: GeminiCliAdapter;
+        let sessionFilePath: string;
+
+        function registerEntry(over: Partial<RegistryEntry> = {}): void {
+            registry.register({
+                name: 'gemini-100',
+                type: 'gemini_cli',
+                pid: 100,
+                tmuxSession: '',
+                cwd: '/repo-a',
+                startedAt: '2026-05-30T00:00:00.000Z',
+                sessionId: 's-cached',
+                sessionFilePath,
+                ...over,
+            });
+        }
+
+        beforeEach(() => {
+            regPath = path.join(tmpHome, 'agents.json');
+            registry = new AgentRegistry(regPath);
+            cachedAdapter = new GeminiCliAdapter(registry);
+
+            const now = new Date().toISOString();
+            sessionFilePath = path.join(tmpHome, 'gemini-session.json');
+            fs.writeFileSync(sessionFilePath, JSON.stringify({
+                sessionId: 's-cached',
+                projectHash: 'h',
+                startTime: now,
+                lastUpdated: now,
+                directories: ['/repo-a'],
+                messages: [
+                    { id: 'm1', timestamp: now, type: 'user', content: 'Hello from gemini cache' },
+                ],
+            }));
+        });
+
+        it('short-circuits matching when registry has a valid entry', async () => {
+            registerEntry();
+            const proc: ProcessInfo = {
+                pid: 100,
+                command: 'node /path/to/gemini --help',
+                cwd: '/repo-a',
+                tty: 'ttys001',
+                startTime: new Date(),
+            };
+            mockedListAgentProcesses.mockReturnValue([proc]);
+
+            const agents = await cachedAdapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                type: 'gemini_cli',
+                pid: 100,
+                sessionId: 's-cached',
+                summary: 'Hello from gemini cache',
+            });
+            expect(mockedMatchProcessesToSessions).not.toHaveBeenCalled();
+        });
+
+        it('falls through when no registry entry exists for the pid', async () => {
+            const proc: ProcessInfo = {
+                pid: 100,
+                command: 'node /path/to/gemini --help',
+                cwd: '/repo-a',
+                tty: 'ttys001',
+                startTime: new Date(),
+            };
+            mockedListAgentProcesses.mockReturnValue([proc]);
+
+            const agents = await cachedAdapter.detectAgents();
+
+            expect(agents[0].sessionId).toBe('pid-100');
+        });
+
+        it('falls through when registry entry type does not match', async () => {
+            registerEntry({ type: 'claude' });
+            const proc: ProcessInfo = {
+                pid: 100,
+                command: 'node /path/to/gemini --help',
+                cwd: '/repo-a',
+                tty: 'ttys001',
+                startTime: new Date(),
+            };
+            mockedListAgentProcesses.mockReturnValue([proc]);
+
+            const agents = await cachedAdapter.detectAgents();
+
+            expect(agents[0].sessionId).toBe('pid-100');
+        });
+
+        it('falls through when the cached session file no longer exists', async () => {
+            registerEntry({ sessionFilePath: path.join(tmpHome, 'deleted.json') });
+            const proc: ProcessInfo = {
+                pid: 100,
+                command: 'node /path/to/gemini --help',
+                cwd: '/repo-a',
+                tty: 'ttys001',
+                startTime: new Date(),
+            };
+            mockedListAgentProcesses.mockReturnValue([proc]);
+
+            const agents = await cachedAdapter.detectAgents();
+
+            expect(agents[0].sessionId).toBe('pid-100');
+        });
+    });
+
     describe('discoverSessions', () => {
         it('should return empty when ~/.gemini/tmp does not exist', () => {
             const proc: ProcessInfo = {

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);
+        });
+    });
+});