@ai-devkit/agent-manager 0.19.1 → 0.21.0

package/dist/__tests__/adapters/CodexAdapter.test.js

@@ -86,6 +86,10 @@ describe('CodexAdapter', ()=>{
         });
     });
     describe('detectAgents', ()=>{
+        async function useRealSessionMatcher() {
+            const actualMatching = await vi.importActual('../../utils/matching.js');
+            mockedMatchProcessesToSessions.mockImplementation(actualMatching.matchProcessesToSessions);
+        }
         it('should return empty list when no codex process is running', async ()=>{
             mockedListAgentProcesses.mockReturnValue([]);
             const agents = await adapter.detectAgents();
@@ -194,6 +198,203 @@ describe('CodexAdapter', ()=>{
                 force: true
             });
         });
+        it('should match when session_meta timestamp and file birthtime both align with process start', async ()=>{
+            await useRealSessionMatcher();
+            const processStart = new Date('2026-03-18T15:00:00.000Z');
+            const sessionTimestamp = '2026-03-18T15:00:05.000Z';
+            const processes = [
+                {
+                    pid: 101,
+                    command: 'codex',
+                    cwd: '/repo-a',
+                    tty: 'ttys001',
+                    startTime: processStart
+                }
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-test-'));
+            const sessionsDir = path.join(tmpDir, 'sessions');
+            const dateDir = path.join(sessionsDir, '2026', '03', '18');
+            fs.mkdirSync(dateDir, {
+                recursive: true
+            });
+            const sessionFile = path.join(dateDir, 'sess-aligned.jsonl');
+            fs.writeFileSync(sessionFile, [
+                JSON.stringify({
+                    type: 'session_meta',
+                    payload: {
+                        id: 'sess-aligned',
+                        timestamp: sessionTimestamp,
+                        cwd: '/repo-a'
+                    }
+                }),
+                JSON.stringify({
+                    type: 'event',
+                    timestamp: sessionTimestamp,
+                    payload: {
+                        type: 'token_count',
+                        message: 'Aligned session'
+                    }
+                })
+            ].join('\n'));
+            adapter.codexSessionsDir = sessionsDir;
+            mockedBatchGetSessionFileBirthtimes.mockReturnValue([
+                {
+                    sessionId: 'sess-aligned',
+                    filePath: sessionFile,
+                    projectDir: dateDir,
+                    birthtimeMs: new Date(sessionTimestamp).getTime(),
+                    resolvedCwd: ''
+                }
+            ]);
+            const agents = await adapter.detectAgents();
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                pid: 101,
+                sessionId: 'sess-aligned',
+                summary: 'Aligned session'
+            });
+            fs.rmSync(tmpDir, {
+                recursive: true,
+                force: true
+            });
+        });
+        it('should match late-created session files using session_meta timestamp', async ()=>{
+            await useRealSessionMatcher();
+            const processStart = new Date('2026-03-18T15:00:00.000Z');
+            const sessionTimestamp = '2026-03-18T15:00:10.000Z';
+            const lateBirthtime = new Date('2026-03-18T15:05:30.000Z').getTime();
+            const processes = [
+                {
+                    pid: 102,
+                    command: 'codex',
+                    cwd: '/repo-a',
+                    tty: 'ttys001',
+                    startTime: processStart
+                }
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-test-'));
+            const sessionsDir = path.join(tmpDir, 'sessions');
+            const dateDir = path.join(sessionsDir, '2026', '03', '18');
+            fs.mkdirSync(dateDir, {
+                recursive: true
+            });
+            const sessionFile = path.join(dateDir, 'sess-late.jsonl');
+            fs.writeFileSync(sessionFile, [
+                JSON.stringify({
+                    type: 'session_meta',
+                    payload: {
+                        id: 'sess-late',
+                        timestamp: sessionTimestamp,
+                        cwd: '/repo-a'
+                    }
+                }),
+                JSON.stringify({
+                    type: 'event',
+                    timestamp: sessionTimestamp,
+                    payload: {
+                        type: 'token_count',
+                        message: 'Late file session'
+                    }
+                })
+            ].join('\n'));
+            adapter.codexSessionsDir = sessionsDir;
+            mockedBatchGetSessionFileBirthtimes.mockReturnValue([
+                {
+                    sessionId: 'sess-late',
+                    filePath: sessionFile,
+                    projectDir: dateDir,
+                    birthtimeMs: lateBirthtime,
+                    resolvedCwd: ''
+                }
+            ]);
+            const agents = await adapter.detectAgents();
+            expect(agents).toHaveLength(1);
+            expect(agents[0]).toMatchObject({
+                pid: 102,
+                sessionId: 'sess-late',
+                summary: 'Late file session'
+            });
+            expect(mockedMatchProcessesToSessions.mock.calls[0][1][0].birthtimeMs).toBe(new Date(sessionTimestamp).getTime());
+            fs.rmSync(tmpDir, {
+                recursive: true,
+                force: true
+            });
+        });
+        it.each([
+            [
+                'missing',
+                undefined
+            ],
+            [
+                'invalid',
+                'not-a-date'
+            ]
+        ])('should fall back to file birthtime when session_meta timestamp is %s', async (_label, metaTimestamp)=>{
+            await useRealSessionMatcher();
+            const processStart = new Date('2026-03-18T15:00:00.000Z');
+            const fileBirthtime = new Date('2026-03-18T15:00:20.000Z').getTime();
+            const processes = [
+                {
+                    pid: 103,
+                    command: 'codex',
+                    cwd: '/repo-a',
+                    tty: 'ttys001',
+                    startTime: processStart
+                }
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-test-'));
+            const sessionsDir = path.join(tmpDir, 'sessions');
+            const dateDir = path.join(sessionsDir, '2026', '03', '18');
+            fs.mkdirSync(dateDir, {
+                recursive: true
+            });
+            const payload = {
+                id: `sess-${_label}`,
+                cwd: '/repo-a'
+            };
+            if (metaTimestamp !== undefined) {
+                payload.timestamp = metaTimestamp;
+            }
+            const sessionFile = path.join(dateDir, `sess-${_label}.jsonl`);
+            fs.writeFileSync(sessionFile, [
+                JSON.stringify({
+                    type: 'session_meta',
+                    payload
+                }),
+                JSON.stringify({
+                    type: 'event',
+                    timestamp: '2026-03-18T15:00:30.000Z',
+                    payload: {
+                        type: 'token_count',
+                        message: `${_label} timestamp session`
+                    }
+                })
+            ].join('\n'));
+            adapter.codexSessionsDir = sessionsDir;
+            mockedBatchGetSessionFileBirthtimes.mockReturnValue([
+                {
+                    sessionId: `sess-${_label}`,
+                    filePath: sessionFile,
+                    projectDir: dateDir,
+                    birthtimeMs: fileBirthtime,
+                    resolvedCwd: ''
+                }
+            ]);
+            const agents = await adapter.detectAgents();
+            expect(agents).toHaveLength(1);
+            expect(agents[0].sessionId).toBe(`sess-${_label}`);
+            expect(mockedMatchProcessesToSessions.mock.calls[0][1][0].birthtimeMs).toBe(fileBirthtime);
+            fs.rmSync(tmpDir, {
+                recursive: true,
+                force: true
+            });
+        });
         it('should fall back to process-only for unmatched processes', async ()=>{
             const processes = [
                 {
@@ -434,6 +635,169 @@ describe('CodexAdapter', ()=>{
                 });
             }
         });
+        it('should map a running Codex process from the hook session mapping', async ()=>{
+            const originalHome = process.env.HOME;
+            const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-mapping-'));
+            process.env.HOME = tmpHome;
+            try {
+                const mappedAdapter = new CodexAdapter(new AgentRegistry(path.join(tmpHome, 'agents.json')));
+                const sessionsDir = path.join(tmpHome, '.codex', 'sessions');
+                const dateDir = path.join(sessionsDir, '2026', '06', '26');
+                const mappingPath = path.join(tmpHome, '.codex', 'ai-devkit', 'sessions.json');
+                const sessionFile = path.join(dateDir, 'rollout-2026-06-26T09-56-12-sess-mapped.jsonl');
+                const recentTs = new Date().toISOString();
+                fs.mkdirSync(dateDir, {
+                    recursive: true
+                });
+                fs.mkdirSync(path.dirname(mappingPath), {
+                    recursive: true
+                });
+                fs.writeFileSync(sessionFile, [
+                    JSON.stringify({
+                        type: 'session_meta',
+                        payload: {
+                            id: 'sess-mapped',
+                            timestamp: recentTs,
+                            cwd: '/repo-mapped'
+                        }
+                    }),
+                    JSON.stringify({
+                        type: 'event',
+                        timestamp: recentTs,
+                        payload: {
+                            type: 'agent_message',
+                            message: 'mapped conversation'
+                        }
+                    })
+                ].join('\n'));
+                fs.writeFileSync(mappingPath, JSON.stringify({
+                    5151: sessionFile
+                }));
+                const processes = [
+                    {
+                        pid: 5151,
+                        command: 'codex',
+                        cwd: '/repo-mapped',
+                        tty: 'ttys001',
+                        startTime: new Date('2026-06-26T09:56:12.000Z')
+                    }
+                ];
+                mockedListAgentProcesses.mockReturnValue(processes);
+                mockedEnrichProcesses.mockReturnValue(processes);
+                const agents = await mappedAdapter.detectAgents();
+                expect(agents).toHaveLength(1);
+                expect(agents[0]).toMatchObject({
+                    type: 'codex',
+                    pid: 5151,
+                    sessionId: 'sess-mapped',
+                    projectPath: '/repo-mapped',
+                    summary: 'mapped conversation',
+                    sessionFilePath: sessionFile
+                });
+                expect(mockedBatchGetSessionFileBirthtimes).not.toHaveBeenCalled();
+                expect(mockedMatchProcessesToSessions).not.toHaveBeenCalled();
+            } finally{
+                process.env.HOME = originalHome;
+                fs.rmSync(tmpHome, {
+                    recursive: true,
+                    force: true
+                });
+            }
+        });
+        it('should fall back to legacy matching when mapped session file cannot be parsed', async ()=>{
+            const originalHome = process.env.HOME;
+            const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-mapping-fallback-'));
+            process.env.HOME = tmpHome;
+            try {
+                const mappedAdapter = new CodexAdapter(new AgentRegistry(path.join(tmpHome, 'agents.json')));
+                const sessionsDir = path.join(tmpHome, '.codex', 'sessions');
+                const dateDir = path.join(sessionsDir, '2026', '06', '26');
+                const mappingPath = path.join(tmpHome, '.codex', 'ai-devkit', 'sessions.json');
+                const badSessionFile = path.join(dateDir, 'bad.jsonl');
+                const fallbackSessionFile = path.join(dateDir, 'fallback.jsonl');
+                const recentTs = new Date().toISOString();
+                fs.mkdirSync(dateDir, {
+                    recursive: true
+                });
+                fs.mkdirSync(path.dirname(mappingPath), {
+                    recursive: true
+                });
+                fs.writeFileSync(badSessionFile, '{not-json');
+                fs.writeFileSync(fallbackSessionFile, [
+                    JSON.stringify({
+                        type: 'session_meta',
+                        payload: {
+                            id: 'sess-fallback',
+                            timestamp: recentTs,
+                            cwd: '/repo-fallback'
+                        }
+                    }),
+                    JSON.stringify({
+                        type: 'event',
+                        timestamp: recentTs,
+                        payload: {
+                            type: 'token_count',
+                            message: 'fallback conversation'
+                        }
+                    })
+                ].join('\n'));
+                fs.writeFileSync(mappingPath, JSON.stringify({
+                    6161: badSessionFile
+                }));
+                const processes = [
+                    {
+                        pid: 6161,
+                        command: 'codex',
+                        cwd: '/repo-fallback',
+                        tty: 'ttys001',
+                        startTime: new Date('2026-06-26T09:56:12.000Z')
+                    }
+                ];
+                const fallbackSession = {
+                    sessionId: 'sess-fallback',
+                    filePath: fallbackSessionFile,
+                    projectDir: dateDir,
+                    birthtimeMs: new Date('2026-06-26T09:56:15.000Z').getTime(),
+                    resolvedCwd: ''
+                };
+                mockedListAgentProcesses.mockReturnValue(processes);
+                mockedEnrichProcesses.mockReturnValue(processes);
+                mockedBatchGetSessionFileBirthtimes.mockReturnValue([
+                    fallbackSession
+                ]);
+                mockedMatchProcessesToSessions.mockReturnValue([
+                    {
+                        process: processes[0],
+                        session: {
+                            ...fallbackSession,
+                            resolvedCwd: '/repo-fallback'
+                        },
+                        deltaMs: 3000
+                    }
+                ]);
+                const agents = await mappedAdapter.detectAgents();
+                expect(agents).toHaveLength(1);
+                expect(agents[0]).toMatchObject({
+                    pid: 6161,
+                    sessionId: 'sess-fallback',
+                    summary: 'fallback conversation',
+                    sessionFilePath: fallbackSessionFile
+                });
+                expect(mockedMatchProcessesToSessions).toHaveBeenCalledWith([
+                    processes[0]
+                ], expect.arrayContaining([
+                    expect.objectContaining({
+                        filePath: fallbackSessionFile
+                    })
+                ]));
+            } finally{
+                process.env.HOME = originalHome;
+                fs.rmSync(tmpHome, {
+                    recursive: true,
+                    force: true
+                });
+            }
+        });
     });
     describe('detectAgents — registry cache short-circuit', ()=>{
         let tmpDir;
@@ -699,6 +1063,149 @@ describe('CodexAdapter', ()=>{
             const { sessions } = discoverSessions(processes);
             expect(sessions[0].resolvedCwd).toBe('');
         });
+        it('should use session_meta timestamp as the matching birthtime when valid', ()=>{
+            const sessionsDir = path.join(tmpDir, 'sessions');
+            adapter.codexSessionsDir = sessionsDir;
+            const discoverSessions = adapter.discoverSessions.bind(adapter);
+            const dateDir = path.join(sessionsDir, '2026', '03', '18');
+            fs.mkdirSync(dateDir, {
+                recursive: true
+            });
+            const sessionFile = path.join(dateDir, 'sess-meta-time.jsonl');
+            const metaTimestamp = '2026-03-18T15:00:05.000Z';
+            fs.writeFileSync(sessionFile, JSON.stringify({
+                type: 'session_meta',
+                payload: {
+                    id: 'sess-meta-time',
+                    timestamp: metaTimestamp,
+                    cwd: '/repo-a'
+                }
+            }));
+            mockedBatchGetSessionFileBirthtimes.mockReturnValue([
+                {
+                    sessionId: 'sess-meta-time',
+                    filePath: sessionFile,
+                    projectDir: dateDir,
+                    birthtimeMs: new Date('2026-03-18T15:05:30.000Z').getTime(),
+                    resolvedCwd: ''
+                }
+            ]);
+            const { sessions } = discoverSessions([
+                {
+                    pid: 1,
+                    command: 'codex',
+                    cwd: '/repo-a',
+                    tty: '',
+                    startTime: new Date('2026-03-18T15:00:00Z')
+                }
+            ]);
+            expect(sessions[0].resolvedCwd).toBe('/repo-a');
+            expect(sessions[0].birthtimeMs).toBe(new Date(metaTimestamp).getTime());
+        });
+        it('should tolerate malformed session_meta and unreadable files', ()=>{
+            const sessionsDir = path.join(tmpDir, 'sessions');
+            adapter.codexSessionsDir = sessionsDir;
+            const discoverSessions = adapter.discoverSessions.bind(adapter);
+            const dateDir = path.join(sessionsDir, '2026', '03', '18');
+            fs.mkdirSync(dateDir, {
+                recursive: true
+            });
+            const malformedFile = path.join(dateDir, 'malformed.jsonl');
+            const missingFile = path.join(dateDir, 'missing.jsonl');
+            fs.writeFileSync(malformedFile, '{not valid json');
+            mockedBatchGetSessionFileBirthtimes.mockReturnValue([
+                {
+                    sessionId: 'malformed',
+                    filePath: malformedFile,
+                    projectDir: dateDir,
+                    birthtimeMs: 1710800324000,
+                    resolvedCwd: ''
+                },
+                {
+                    sessionId: 'missing',
+                    filePath: missingFile,
+                    projectDir: dateDir,
+                    birthtimeMs: 1710800325000,
+                    resolvedCwd: ''
+                }
+            ]);
+            const result = discoverSessions([
+                {
+                    pid: 1,
+                    command: 'codex',
+                    cwd: '/repo',
+                    tty: '',
+                    startTime: new Date('2026-03-18T15:00:00Z')
+                }
+            ]);
+            expect(result.sessions).toHaveLength(2);
+            expect(result.sessions[0].resolvedCwd).toBe('');
+            expect(result.sessions[1].resolvedCwd).toBe('');
+            expect(result.contentCache.has(malformedFile)).toBe(true);
+            expect(result.contentCache.has(missingFile)).toBe(false);
+        });
+    });
+    describe('findSessionFileById', ()=>{
+        let tmpDir;
+        let sessionsDir;
+        const sessionId = 'aaaaaaaa-bbbb-4ccc-dddd-eeeeeeeeeeee';
+        beforeEach(()=>{
+            tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-resume-find-'));
+            sessionsDir = path.join(tmpDir, 'sessions');
+            fs.mkdirSync(path.join(sessionsDir, '2026', '03', '18'), {
+                recursive: true
+            });
+            adapter.codexSessionsDir = sessionsDir;
+        });
+        afterEach(()=>{
+            fs.rmSync(tmpDir, {
+                recursive: true,
+                force: true
+            });
+        });
+        function writeResumeSession(timestamp) {
+            const filePath = path.join(sessionsDir, '2026', '03', '18', `${sessionId}.jsonl`);
+            const payload = {
+                id: sessionId,
+                cwd: '/repo-a'
+            };
+            if (timestamp !== undefined) {
+                payload.timestamp = timestamp;
+            }
+            fs.writeFileSync(filePath, JSON.stringify({
+                type: 'session_meta',
+                payload
+            }));
+            return filePath;
+        }
+        it('should return session_meta timestamp as birthtimeMs when valid', ()=>{
+            const metaTimestamp = '2026-03-18T15:00:05.000Z';
+            writeResumeSession(metaTimestamp);
+            const findSessionFileById = adapter.findSessionFileById.bind(adapter);
+            const session = findSessionFileById(sessionId);
+            expect(session).toMatchObject({
+                sessionId,
+                resolvedCwd: '/repo-a',
+                birthtimeMs: new Date(metaTimestamp).getTime()
+            });
+        });
+        it.each([
+            [
+                'missing',
+                undefined
+            ],
+            [
+                'invalid',
+                'not-a-date'
+            ]
+        ])('should fall back to stat birthtimeMs when session_meta timestamp is %s', (_label, metaTimestamp)=>{
+            const sessionFile = writeResumeSession(metaTimestamp);
+            const stat = fs.statSync(sessionFile);
+            const findSessionFileById = adapter.findSessionFileById.bind(adapter);
+            const session = findSessionFileById(sessionId);
+            expect(session).not.toBeNull();
+            expect(session.birthtimeMs).toBe(stat.birthtimeMs);
+        });
     });
     describe('helper methods', ()=>{
         describe('determineStatus', ()=>{