@ai-devkit/agent-manager 0.10.0 → 0.12.0

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

@@ -18,9 +18,13 @@ jest.mock('../../utils/process', () => ({
     enrichProcesses: jest.fn(),
 }));
 
-jest.mock('../../utils/session', () => ({
-    batchGetSessionFileBirthtimes: jest.fn(),
-}));
+jest.mock('../../utils/session', () => {
+    const actual = jest.requireActual('../../utils/session') as typeof import('../../utils/session');
+    return {
+        ...actual,
+        batchGetSessionFileBirthtimes: jest.fn(),
+    };
+});
 
 jest.mock('../../utils/matching', () => ({
     matchProcessesToSessions: jest.fn(),
@@ -285,6 +289,76 @@ describe('ClaudeCodeAdapter', () => {
             });
         });
 
+        it('should match via --resume <uuid> in command line and skip PID-file/legacy', async () => {
+            const sessionId = '0555f803-7eca-4fc6-a1e0-34dbf86b33b2';
+            const processes: ProcessInfo[] = [
+                {
+                    pid: 41920,
+                    command: `claude --resume ${sessionId}`,
+                    cwd: '/project/resumed',
+                    tty: 'ttys001',
+                    startTime: new Date(),
+                },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+
+            const tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'claude-resume-'));
+            const projectsDir = path.join(tmpDir, 'projects');
+            const projDir = path.join(projectsDir, '-project-resumed');
+            fs.mkdirSync(projDir, { recursive: true });
+
+            const jsonlPath = path.join(projDir, `${sessionId}.jsonl`);
+            fs.writeFileSync(jsonlPath, [
+                JSON.stringify({ type: 'user', timestamp: new Date().toISOString(), cwd: '/project/resumed', message: { content: 'resumed conversation' } }),
+                JSON.stringify({ type: 'assistant', timestamp: new Date().toISOString() }),
+            ].join('\n'));
+
+            (adapter as any).projectsDir = projectsDir;
+            (adapter as any).sessionsDir = path.join(tmpDir, 'sessions'); // empty — no PID file
+
+            const agents = await adapter.detectAgents();
+
+            // Legacy matching helpers must NOT have been consulted — resume match was authoritative
+            expect(mockedBatchGetSessionFileBirthtimes).not.toHaveBeenCalled();
+            expect(mockedMatchProcessesToSessions).not.toHaveBeenCalled();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                type: 'claude',
+                pid: 41920,
+                sessionId,
+                projectPath: '/project/resumed',
+            });
+            expect(agents[0].summary).toContain('resumed conversation');
+
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
+        it('should fall through when --resume points to a JSONL that does not exist', async () => {
+            const processes: ProcessInfo[] = [
+                {
+                    pid: 41921,
+                    command: 'claude --resume aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee',
+                    cwd: '/project/missing',
+                    tty: 'ttys001',
+                    startTime: new Date(),
+                },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+
+            // No projects dir, no PID file → both matchers fail → process-only
+            (adapter as any).projectsDir = '/nonexistent';
+            (adapter as any).sessionsDir = '/nonexistent';
+
+            const agents = await adapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0].sessionId).toBe('pid-41921');
+            expect(agents[0].status).toBe(AgentStatus.IDLE);
+        });
+
         it('should use PID file for direct match and skip legacy matching for that process', async () => {
             const startTime = new Date();
             const processes: ProcessInfo[] = [
@@ -1288,4 +1362,156 @@ describe('ClaudeCodeAdapter', () => {
             expect(messages[0].content).toBe('Real question');
         });
     });
+
+    describe('listSessions', () => {
+        let tmpDir: string;
+        let projectsDir: string;
+
+        beforeEach(() => {
+            tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'claude-list-'));
+            projectsDir = path.join(tmpDir, 'projects');
+            fs.mkdirSync(projectsDir, { recursive: true });
+            (adapter as any).projectsDir = projectsDir;
+        });
+
+        afterEach(() => {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
+        function writeSession(projectDir: string, sessionId: string, lines: object[]): string {
+            fs.mkdirSync(projectDir, { recursive: true });
+            const filePath = path.join(projectDir, `${sessionId}.jsonl`);
+            fs.writeFileSync(filePath, lines.map((l) => JSON.stringify(l)).join('\n'));
+            return filePath;
+        }
+
+        it('returns empty when projects dir does not exist', async () => {
+            fs.rmSync(projectsDir, { recursive: true, force: true });
+            const result = await adapter.listSessions();
+            expect(result).toEqual([]);
+        });
+
+        it('returns sessions from a single cwd-scoped project dir', async () => {
+            const cwd = '/Users/test/proj';
+            const projDir = path.join(projectsDir, '-Users-test-proj');
+            const filePath = writeSession(projDir, 'sess-1', [
+                { type: 'user', timestamp: '2025-01-01T00:00:00Z', cwd, message: { content: 'first prompt' } },
+                { type: 'assistant', timestamp: '2025-01-01T00:01:00Z' },
+            ]);
+
+            const result = await adapter.listSessions({ cwd });
+
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                type: 'claude',
+                sessionId: 'sess-1',
+                cwd,
+                firstUserMessage: 'first prompt',
+                sessionFilePath: filePath,
+            });
+            expect(result[0].lastActive).toBeInstanceOf(Date);
+            expect(result[0].startedAt).toBeInstanceOf(Date);
+        });
+
+        it('lists sessions from all project dirs when no cwd filter', async () => {
+            const cwdA = '/Users/test/proj-a';
+            const cwdB = '/Users/test/proj-b';
+            writeSession(path.join(projectsDir, '-Users-test-proj-a'), 'a', [
+                { type: 'user', timestamp: '2025-01-01T00:00:00Z', cwd: cwdA, message: { content: 'msg-a' } },
+            ]);
+            writeSession(path.join(projectsDir, '-Users-test-proj-b'), 'b', [
+                { type: 'user', timestamp: '2025-01-02T00:00:00Z', cwd: cwdB, message: { content: 'msg-b' } },
+            ]);
+
+            const result = await adapter.listSessions();
+
+            expect(result).toHaveLength(2);
+            expect(result.map((r) => r.sessionId).sort()).toEqual(['a', 'b']);
+            const cwds = result.map((r) => r.cwd).sort();
+            expect(cwds).toEqual([cwdA, cwdB]);
+        });
+
+        it('drops sessions whose recorded cwd does not match opts.cwd (strict equality)', async () => {
+            const cwdReal = '/Users/test/foo';
+            const cwdRequested = '/Users/test/foo/sub';
+            writeSession(path.join(projectsDir, '-Users-test-foo'), 's', [
+                { type: 'user', timestamp: '2025-01-01T00:00:00Z', cwd: cwdReal, message: { content: 'hi' } },
+            ]);
+
+            // Encoded dir for the requested cwd doesn't exist → return []
+            const result = await adapter.listSessions({ cwd: cwdRequested });
+            expect(result).toEqual([]);
+        });
+
+        it('drops sessions whose recorded cwd disagrees with the encoded dir', async () => {
+            // Edge case: encoded dir lookup matches, but session content
+            // records a different cwd. Strict-equality filter must reject.
+            const requested = '/Users/test/proj';
+            const projDir = path.join(projectsDir, '-Users-test-proj');
+            writeSession(projDir, 's', [
+                { type: 'user', timestamp: '2025-01-01T00:00:00Z', cwd: '/different/path', message: { content: 'mismatch' } },
+            ]);
+
+            const result = await adapter.listSessions({ cwd: requested });
+            expect(result).toEqual([]);
+        });
+
+        it('finds sessions whose recorded cwd lives in a different encoded dir (worktree case)', async () => {
+            // Real-world case: Claude Code is launched in /repo, then chdirs into
+            // /repo/.worktrees/feature. The session file is stored under the
+            // ENCODED launch dir, but its content records the worktree path.
+            // listSessions({ cwd: worktree }) must still find it.
+            const launchDir = path.join(projectsDir, '-repo');
+            const worktreeCwd = '/repo/.worktrees/feature';
+            writeSession(launchDir, 'wt', [
+                { type: 'user', timestamp: '2025-01-01T00:00:00Z', cwd: worktreeCwd, message: { content: 'in worktree' } },
+            ]);
+
+            const result = await adapter.listSessions({ cwd: worktreeCwd });
+            expect(result).toHaveLength(1);
+            expect(result[0]).toMatchObject({
+                sessionId: 'wt',
+                cwd: worktreeCwd,
+                firstUserMessage: 'in worktree',
+            });
+        });
+
+        it('skips malformed session files', async () => {
+            const cwd = '/Users/test/p';
+            const projDir = path.join(projectsDir, '-Users-test-p');
+            fs.mkdirSync(projDir, { recursive: true });
+            fs.writeFileSync(path.join(projDir, 'bad.jsonl'), 'not valid json');
+            writeSession(projDir, 'good', [
+                { type: 'user', timestamp: '2025-01-01T00:00:00Z', cwd, message: { content: 'ok' } },
+            ]);
+
+            const result = await adapter.listSessions({ cwd });
+            expect(result).toHaveLength(1);
+            expect(result[0].sessionId).toBe('good');
+        });
+
+        it('captures first user message after filtering noise', async () => {
+            const cwd = '/Users/test/q';
+            writeSession(path.join(projectsDir, '-Users-test-q'), 's', [
+                { type: 'user', timestamp: '2025-01-01T00:00:00Z', cwd, message: { content: 'Tool loaded.' } },
+                { type: 'user', timestamp: '2025-01-01T00:00:01Z', cwd, message: { content: 'real first prompt' } },
+                { type: 'user', timestamp: '2025-01-01T00:00:02Z', cwd, message: { content: 'second prompt' } },
+            ]);
+
+            const result = await adapter.listSessions({ cwd });
+            expect(result).toHaveLength(1);
+            expect(result[0].firstUserMessage).toBe('real first prompt');
+        });
+
+        it('returns empty firstUserMessage when no user message exists', async () => {
+            const cwd = '/Users/test/empty';
+            writeSession(path.join(projectsDir, '-Users-test-empty'), 's', [
+                { type: 'assistant', timestamp: '2025-01-01T00:00:00Z' },
+            ]);
+
+            const result = await adapter.listSessions({ cwd });
+            expect(result).toHaveLength(1);
+            expect(result[0].firstUserMessage).toBe('');
+        });
+    });
 });

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

@@ -19,9 +19,13 @@ jest.mock('../../utils/process', () => ({
     enrichProcesses: jest.fn(),
 }));
 
-jest.mock('../../utils/session', () => ({
-    batchGetSessionFileBirthtimes: jest.fn(),
-}));
+jest.mock('../../utils/session', () => {
+    const actual = jest.requireActual('../../utils/session') as typeof import('../../utils/session');
+    return {
+        ...actual,
+        batchGetSessionFileBirthtimes: jest.fn(),
+    };
+});
 
 jest.mock('../../utils/matching', () => ({
     matchProcessesToSessions: jest.fn(),
@@ -630,4 +634,120 @@ describe('CodexAdapter', () => {
             expect(messages[0].content).toBe('Response');
         });
     });
+
+    describe('listSessions', () => {
+        let tmpDir: string;
+        let sessionsDir: string;
+
+        beforeEach(() => {
+            tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'codex-list-'));
+            sessionsDir = path.join(tmpDir, 'sessions');
+            fs.mkdirSync(sessionsDir, { recursive: true });
+            (adapter as any).codexSessionsDir = sessionsDir;
+        });
+
+        afterEach(() => {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
+        function writeCodexSession(dateDir: string, sessionId: string, lines: object[]): string {
+            fs.mkdirSync(dateDir, { recursive: true });
+            const filePath = path.join(dateDir, `${sessionId}.jsonl`);
+            fs.writeFileSync(filePath, lines.map((l) => JSON.stringify(l)).join('\n'));
+            return filePath;
+        }
+
+        it('returns empty when sessions dir does not exist', async () => {
+            fs.rmSync(sessionsDir, { recursive: true, force: true });
+            const result = await adapter.listSessions();
+            expect(result).toEqual([]);
+        });
+
+        it('walks every YYYY/MM/DD dir and returns all sessions', async () => {
+            const dayA = path.join(sessionsDir, '2025', '01', '01');
+            const dayB = path.join(sessionsDir, '2025', '02', '03');
+            writeCodexSession(dayA, 'sess-a', [
+                { type: 'session_meta', payload: { id: 'sess-a', cwd: '/repo-a', timestamp: '2025-01-01T00:00:00Z' } },
+                { type: 'event', timestamp: '2025-01-01T00:00:01Z', payload: { type: 'user_message', message: 'msg-a' } },
+            ]);
+            writeCodexSession(dayB, 'sess-b', [
+                { type: 'session_meta', payload: { id: 'sess-b', cwd: '/repo-b', timestamp: '2025-02-03T00:00:00Z' } },
+                { type: 'event', timestamp: '2025-02-03T00:00:01Z', payload: { type: 'user_message', message: 'msg-b' } },
+            ]);
+
+            const result = await adapter.listSessions();
+
+            expect(result).toHaveLength(2);
+            const byId = Object.fromEntries(result.map((r) => [r.sessionId, r]));
+            expect(byId['sess-a']).toMatchObject({
+                type: 'codex',
+                cwd: '/repo-a',
+                firstUserMessage: 'msg-a',
+            });
+            expect(byId['sess-b']).toMatchObject({
+                type: 'codex',
+                cwd: '/repo-b',
+                firstUserMessage: 'msg-b',
+            });
+        });
+
+        it('applies strict-equality cwd filter against session_meta cwd', async () => {
+            const day = path.join(sessionsDir, '2025', '01', '01');
+            writeCodexSession(day, 'keep', [
+                { type: 'session_meta', payload: { id: 'keep', cwd: '/repo', timestamp: '2025-01-01T00:00:00Z' } },
+                { type: 'event', timestamp: '2025-01-01T00:00:01Z', payload: { type: 'user_message', message: 'yes' } },
+            ]);
+            writeCodexSession(day, 'drop', [
+                { type: 'session_meta', payload: { id: 'drop', cwd: '/other', timestamp: '2025-01-01T00:01:00Z' } },
+                { type: 'event', timestamp: '2025-01-01T00:01:01Z', payload: { type: 'user_message', message: 'no' } },
+            ]);
+
+            const result = await adapter.listSessions({ cwd: '/repo' });
+
+            expect(result).toHaveLength(1);
+            expect(result[0].sessionId).toBe('keep');
+        });
+
+        it('skips files without a session_meta first line', async () => {
+            const day = path.join(sessionsDir, '2025', '01', '01');
+            writeCodexSession(day, 'bad', [
+                { type: 'event', timestamp: '2025-01-01T00:00:00Z', payload: { type: 'user_message', message: 'orphan' } },
+            ]);
+            writeCodexSession(day, 'good', [
+                { type: 'session_meta', payload: { id: 'good', cwd: '/repo', timestamp: '2025-01-01T00:00:00Z' } },
+                { type: 'event', timestamp: '2025-01-01T00:00:01Z', payload: { type: 'user_message', message: 'ok' } },
+            ]);
+
+            const result = await adapter.listSessions();
+            expect(result).toHaveLength(1);
+            expect(result[0].sessionId).toBe('good');
+        });
+
+        it('captures the first user_message as firstUserMessage', async () => {
+            const day = path.join(sessionsDir, '2025', '01', '01');
+            writeCodexSession(day, 's', [
+                { type: 'session_meta', payload: { id: 's', cwd: '/repo', timestamp: '2025-01-01T00:00:00Z' } },
+                { type: 'event', timestamp: '2025-01-01T00:00:01Z', payload: { type: 'agent_message', message: 'preamble' } },
+                { type: 'event', timestamp: '2025-01-01T00:00:02Z', payload: { type: 'user_message', message: 'first user' } },
+                { type: 'event', timestamp: '2025-01-01T00:00:03Z', payload: { type: 'user_message', message: 'second user' } },
+            ]);
+
+            const result = await adapter.listSessions({ cwd: '/repo' });
+
+            expect(result).toHaveLength(1);
+            expect(result[0].firstUserMessage).toBe('first user');
+        });
+
+        it('returns empty firstUserMessage when no user_message exists', async () => {
+            const day = path.join(sessionsDir, '2025', '01', '01');
+            writeCodexSession(day, 's', [
+                { type: 'session_meta', payload: { id: 's', cwd: '/repo', timestamp: '2025-01-01T00:00:00Z' } },
+                { type: 'event', timestamp: '2025-01-01T00:00:01Z', payload: { type: 'agent_message', message: 'agent only' } },
+            ]);
+
+            const result = await adapter.listSessions({ cwd: '/repo' });
+            expect(result).toHaveLength(1);
+            expect(result[0].firstUserMessage).toBe('');
+        });
+    });
 });

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

@@ -760,6 +760,139 @@ describe('GeminiCliAdapter', () => {
             expect(adapter.getConversation(sessionPath)).toEqual([]);
         });
     });
+
+    describe('listSessions', () => {
+        it('returns empty when ~/.gemini/tmp does not exist', async () => {
+            // tmpHome has no .gemini dir by default
+            const result = await adapter.listSessions();
+            expect(result).toEqual([]);
+        });
+
+        it('walks every shortId/chats dir and returns sessions', async () => {
+            writeSession(tmpHome, 'aaa', 'session-1', {
+                sessionId: 's-1',
+                projectHash: hashProjectRoot('/repo-a'),
+                startTime: '2025-01-01T00:00:00Z',
+                lastUpdated: '2025-01-01T00:01:00Z',
+                directories: ['/repo-a'],
+                messages: [
+                    { type: 'user', timestamp: '2025-01-01T00:00:00Z', content: [{ text: 'hello a' }] },
+                ],
+            });
+            writeSession(tmpHome, 'bbb', 'session-2', {
+                sessionId: 's-2',
+                projectHash: hashProjectRoot('/repo-b'),
+                startTime: '2025-01-02T00:00:00Z',
+                lastUpdated: '2025-01-02T00:01:00Z',
+                directories: ['/repo-b'],
+                messages: [
+                    { type: 'user', timestamp: '2025-01-02T00:00:00Z', content: [{ text: 'hello b' }] },
+                ],
+            });
+
+            const result = await adapter.listSessions();
+
+            expect(result).toHaveLength(2);
+            const byId = Object.fromEntries(result.map((r) => [r.sessionId, r]));
+            expect(byId['s-1']).toMatchObject({
+                type: 'gemini_cli',
+                cwd: '/repo-a',
+                firstUserMessage: 'hello a',
+            });
+            expect(byId['s-2']).toMatchObject({
+                type: 'gemini_cli',
+                cwd: '/repo-b',
+                firstUserMessage: 'hello b',
+            });
+        });
+
+        it('applies strict-equality cwd filter against directories[0]', async () => {
+            writeSession(tmpHome, 'aaa', 'session-keep', {
+                sessionId: 'keep',
+                projectHash: hashProjectRoot('/repo'),
+                startTime: '2025-01-01T00:00:00Z',
+                directories: ['/repo'],
+                messages: [{ type: 'user', timestamp: '2025-01-01T00:00:00Z', content: 'yes' }],
+            });
+            writeSession(tmpHome, 'bbb', 'session-drop', {
+                sessionId: 'drop',
+                projectHash: hashProjectRoot('/other'),
+                startTime: '2025-01-01T00:00:00Z',
+                directories: ['/other'],
+                messages: [{ type: 'user', timestamp: '2025-01-01T00:00:00Z', content: 'no' }],
+            });
+
+            const result = await adapter.listSessions({ cwd: '/repo' });
+
+            expect(result).toHaveLength(1);
+            expect(result[0].sessionId).toBe('keep');
+        });
+
+        it('skips malformed JSON files', async () => {
+            const chatsDir = path.join(tmpHome, '.gemini', 'tmp', 'aaa', 'chats');
+            fs.mkdirSync(chatsDir, { recursive: true });
+            fs.writeFileSync(path.join(chatsDir, 'session-bad.json'), '{ not json');
+            writeSession(tmpHome, 'aaa', 'session-good', {
+                sessionId: 'good',
+                projectHash: hashProjectRoot('/repo'),
+                startTime: '2025-01-01T00:00:00Z',
+                directories: ['/repo'],
+                messages: [{ type: 'user', timestamp: '2025-01-01T00:00:00Z', content: 'ok' }],
+            });
+
+            const result = await adapter.listSessions();
+            expect(result).toHaveLength(1);
+            expect(result[0].sessionId).toBe('good');
+        });
+
+        it('skips files missing sessionId', async () => {
+            writeSession(tmpHome, 'aaa', 'session-no-id', {
+                projectHash: hashProjectRoot('/repo'),
+                startTime: '2025-01-01T00:00:00Z',
+                directories: ['/repo'],
+                messages: [],
+            });
+
+            const result = await adapter.listSessions();
+            expect(result).toEqual([]);
+        });
+
+        it('captures the first user-typed message as firstUserMessage', async () => {
+            writeSession(tmpHome, 'aaa', 'session-x', {
+                sessionId: 's',
+                projectHash: hashProjectRoot('/repo'),
+                startTime: '2025-01-01T00:00:00Z',
+                directories: ['/repo'],
+                messages: [
+                    { type: 'gemini', timestamp: '2025-01-01T00:00:00Z', content: 'preamble' },
+                    { type: 'user', timestamp: '2025-01-01T00:00:01Z', content: [{ text: 'first user' }] },
+                    { type: 'user', timestamp: '2025-01-01T00:00:02Z', content: 'second user' },
+                ],
+            });
+
+            const result = await adapter.listSessions({ cwd: '/repo' });
+
+            expect(result).toHaveLength(1);
+            expect(result[0].firstUserMessage).toBe('first user');
+        });
+
+        it('returns empty firstUserMessage when no user message exists', async () => {
+            writeSession(tmpHome, 'aaa', 'session-x', {
+                sessionId: 's',
+                projectHash: hashProjectRoot('/repo'),
+                startTime: '2025-01-01T00:00:00Z',
+                directories: ['/repo'],
+                messages: [
+                    { type: 'gemini', timestamp: '2025-01-01T00:00:00Z', content: 'agent only' },
+                ],
+            });
+
+            const result = await adapter.listSessions({ cwd: '/repo' });
+
+            expect(result).toHaveLength(1);
+            expect(result[0].firstUserMessage).toBe('');
+        });
+    });
 });
 
 /**