@ai-devkit/agent-manager 0.14.0 → 0.16.0

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

@@ -2,30 +2,33 @@
  * Tests for GeminiCliAdapter
  */
 
+import type { MockedFunction } from 'vitest';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
-import { beforeEach, afterEach, describe, expect, it, jest } from '@jest/globals';
-import { GeminiCliAdapter } from '../../adapters/GeminiCliAdapter';
-import type { ProcessInfo } from '../../adapters/AgentAdapter';
-import { AgentStatus } from '../../adapters/AgentAdapter';
-import { listAgentProcesses, enrichProcesses } from '../../utils/process';
-import { matchProcessesToSessions, generateAgentName } from '../../utils/matching';
-
-jest.mock('../../utils/process', () => ({
-    listAgentProcesses: jest.fn(),
-    enrichProcesses: jest.fn(),
+
+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';
+
+vi.mock('../../utils/process.js', () => ({
+    listAgentProcesses: vi.fn(),
+    enrichProcesses: vi.fn(),
 }));
 
-jest.mock('../../utils/matching', () => ({
-    matchProcessesToSessions: jest.fn(),
-    generateAgentName: jest.fn(),
+vi.mock('../../utils/matching.js', () => ({
+    matchProcessesToSessions: vi.fn(),
+    generateAgentName: vi.fn(),
 }));
 
-const mockedListAgentProcesses = listAgentProcesses as jest.MockedFunction<typeof listAgentProcesses>;
-const mockedEnrichProcesses = enrichProcesses as jest.MockedFunction<typeof enrichProcesses>;
-const mockedMatchProcessesToSessions = matchProcessesToSessions as jest.MockedFunction<typeof matchProcessesToSessions>;
-const mockedGenerateAgentName = generateAgentName as jest.MockedFunction<typeof generateAgentName>;
+const mockedListAgentProcesses = listAgentProcesses as MockedFunction<typeof listAgentProcesses>;
+const mockedEnrichProcesses = enrichProcesses as MockedFunction<typeof enrichProcesses>;
+const mockedMatchProcessesToSessions = matchProcessesToSessions as MockedFunction<typeof matchProcessesToSessions>;
+const mockedGenerateAgentName = generateAgentName as MockedFunction<typeof generateAgentName>;
 
 describe('GeminiCliAdapter', () => {
     let adapter: GeminiCliAdapter;
@@ -249,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 = {
@@ -918,6 +1031,5 @@ function writeSession(
  */
 function hashProjectRoot(projectRoot: string): string {
     // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const crypto = require('crypto');
     return crypto.createHash('sha256').update(projectRoot).digest('hex');
 }

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

@@ -2,28 +2,30 @@
  * Tests for OpenCodeAdapter
  */
 
+import type { MockedFunction } from 'vitest';
 import * as fs from 'fs';
 import * as path from 'path';
-import { beforeEach, afterEach, describe, expect, it, jest } from '@jest/globals';
-import { OpenCodeAdapter } from '../../adapters/OpenCodeAdapter';
-import type { ProcessInfo } from '../../adapters/AgentAdapter';
-import { AgentStatus } from '../../adapters/AgentAdapter';
-import { listAgentProcesses, enrichProcesses } from '../../utils/process';
-import { generateAgentName } from '../../utils/matching';
-
-jest.mock('../../utils/process', () => ({
-    listAgentProcesses: jest.fn(),
-    enrichProcesses: jest.fn(),
+
+import { OpenCodeAdapter } from '../../adapters/OpenCodeAdapter.js';
+import type { ProcessInfo } from '../../adapters/AgentAdapter.js';
+import { AgentStatus } from '../../adapters/AgentAdapter.js';
+import { listAgentProcesses, enrichProcesses } from '../../utils/process.js';
+import { generateAgentName } from '../../utils/matching.js';
+import * as os from 'os';
+
+vi.mock('../../utils/process.js', () => ({
+    listAgentProcesses: vi.fn(),
+    enrichProcesses: vi.fn(),
 }));
 
-jest.mock('../../utils/matching', () => ({
-    generateAgentName: jest.fn(),
-    matchProcessesToSessions: jest.fn(),
+vi.mock('../../utils/matching.js', () => ({
+    generateAgentName: vi.fn(),
+    matchProcessesToSessions: vi.fn(),
 }));
 
-const mockedListAgentProcesses = listAgentProcesses as jest.MockedFunction<typeof listAgentProcesses>;
-const mockedEnrichProcesses = enrichProcesses as jest.MockedFunction<typeof enrichProcesses>;
-const mockedGenerateAgentName = generateAgentName as jest.MockedFunction<typeof generateAgentName>;
+const mockedListAgentProcesses = listAgentProcesses as MockedFunction<typeof listAgentProcesses>;
+const mockedEnrichProcesses = enrichProcesses as MockedFunction<typeof enrichProcesses>;
+const mockedGenerateAgentName = generateAgentName as MockedFunction<typeof generateAgentName>;
 
 function makeDb(queries: {
     session?: Array<{ id: string; directory: string; time_created: number }>;
@@ -85,11 +87,11 @@ function makeDb(queries: {
         return { all: () => [], get: () => undefined };
     };
 
-    return { prepare: prepareImpl, close: jest.fn() };
+    return { prepare: prepareImpl, close: vi.fn() };
 }
 
 function makeDbConstructor(db: ReturnType<typeof makeDb>) {
-    return jest.fn().mockReturnValue(db);
+    return vi.fn().mockReturnValue(db);
 }
 
 describe('OpenCodeAdapter', () => {
@@ -110,7 +112,7 @@ describe('OpenCodeAdapter', () => {
             return `${folder}-${pid}`;
         });
 
-        tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'opencode-test-'));
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencode-test-'));
         dbPath = path.join(tmpDir, 'opencode.db');
         (adapter as any).dbPath = dbPath;
         (adapter as any).db = null;
@@ -118,7 +120,7 @@ describe('OpenCodeAdapter', () => {
 
     afterEach(() => {
         fs.rmSync(tmpDir, { recursive: true, force: true });
-        jest.restoreAllMocks();
+        vi.restoreAllMocks();
     });
 
     describe('type', () => {
@@ -193,7 +195,7 @@ describe('OpenCodeAdapter', () => {
 
             fs.writeFileSync(dbPath, ''); // file exists but empty → sqlite throws
             const db = makeDb({ session: [] }); // no matching session
-            jest.mock('better-sqlite3', () => makeDbConstructor(db));
+            vi.doMock('better-sqlite3', () => makeDbConstructor(db));
             (adapter as any).db = db;
 
             const agents = await adapter.detectAgents();

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__/terminal/TtyWriter.test.ts

@@ -1,18 +1,19 @@
-import { describe, it, expect, jest, beforeEach } from '@jest/globals';
-import { TtyWriter } from '../../terminal/TtyWriter';
-import { TerminalType } from '../../terminal/TerminalFocusManager';
-import type { TerminalLocation } from '../../terminal/TerminalFocusManager';
+import type { Mock } from 'vitest';
+
+import { TtyWriter } from '../../terminal/TtyWriter.js';
+import { TerminalType } from '../../terminal/TerminalFocusManager.js';
+import type { TerminalLocation } from '../../terminal/TerminalFocusManager.js';
 import { execFile } from 'child_process';
 
-jest.mock('child_process', () => {
-    const actual = jest.requireActual<typeof import('child_process')>('child_process');
+vi.mock('child_process', async () => {
+    const actual = await vi.importActual<typeof import('child_process')>('child_process');
     return {
         ...actual,
-        execFile: jest.fn(),
+        execFile: vi.fn(),
     };
 });
 
-const mockedExecFile = execFile as unknown as jest.Mock;
+const mockedExecFile = execFile as unknown as Mock;
 
 function mockExecFileSuccess(stdout = '') {
     mockedExecFile.mockImplementation((...args: unknown[]) => {
@@ -30,7 +31,7 @@ function mockExecFileError(message: string) {
 
 describe('TtyWriter', () => {
     beforeEach(() => {
-        jest.clearAllMocks();
+        vi.clearAllMocks();
     });
 
     describe('tmux', () => {