@ai-devkit/agent-manager 0.11.0 → 0.13.0

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

@@ -289,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[] = [
@@ -338,6 +408,194 @@ describe('ClaudeCodeAdapter', () => {
             fs.rmSync(tmpDir, { recursive: true, force: true });
         });
 
+        it('should prefer PID-file live status over JSONL-derived status and surface waitingFor in summary', async () => {
+            const startTime = new Date();
+            const processes: ProcessInfo[] = [
+                { pid: 55050, command: 'claude', cwd: '/project/wait', tty: 'ttys001', startTime },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+
+            const tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'claude-pid-wait-'));
+            const sessionsDir = path.join(tmpDir, 'sessions');
+            const projectsDir = path.join(tmpDir, 'projects');
+            const projDir = path.join(projectsDir, '-project-wait');
+            fs.mkdirSync(sessionsDir, { recursive: true });
+            fs.mkdirSync(projDir, { recursive: true });
+
+            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.
+            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' }),
+            ].join('\n'));
+
+            fs.writeFileSync(
+                path.join(sessionsDir, '55050.json'),
+                JSON.stringify({
+                    pid: 55050, sessionId, cwd: '/project/wait',
+                    startedAt: startTime.getTime(),
+                    kind: 'interactive', entrypoint: 'cli',
+                    status: 'waiting', waitingFor: 'approve Read',
+                }),
+            );
+
+            (adapter as any).sessionsDir = sessionsDir;
+            (adapter as any).projectsDir = projectsDir;
+
+            const agents = await adapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0].status).toBe(AgentStatus.WAITING);
+            expect(agents[0].summary).toContain('/reddit-commenter');
+            expect(agents[0].summary).toContain('waiting for approve Read');
+
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
+        it('should resolve PID-file status: "idle" to AgentStatus.IDLE even when JSONL would say UNKNOWN', async () => {
+            const startTime = new Date();
+            const processes: ProcessInfo[] = [
+                { pid: 55051, command: 'claude', cwd: '/project/idle', tty: 'ttys001', startTime },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+
+            const tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'claude-pid-idle-'));
+            const sessionsDir = path.join(tmpDir, 'sessions');
+            const projectsDir = path.join(tmpDir, 'projects');
+            const projDir = path.join(projectsDir, '-project-idle');
+            fs.mkdirSync(sessionsDir, { recursive: true });
+            fs.mkdirSync(projDir, { recursive: true });
+
+            const sessionId = 'idle-session';
+            const jsonlPath = path.join(projDir, `${sessionId}.jsonl`);
+            fs.writeFileSync(jsonlPath, [
+                JSON.stringify({ type: 'user', timestamp: new Date().toISOString(), cwd: '/project/idle', message: { content: 'hello' } }),
+                JSON.stringify({ type: 'permission-mode', timestamp: new Date().toISOString(), permissionMode: 'default' }),
+            ].join('\n'));
+
+            fs.writeFileSync(
+                path.join(sessionsDir, '55051.json'),
+                JSON.stringify({
+                    pid: 55051, sessionId, cwd: '/project/idle',
+                    startedAt: startTime.getTime(),
+                    kind: 'interactive', entrypoint: 'cli',
+                    status: 'idle',
+                }),
+            );
+
+            (adapter as any).sessionsDir = sessionsDir;
+            (adapter as any).projectsDir = projectsDir;
+
+            const agents = await adapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0].status).toBe(AgentStatus.IDLE);
+            // No waitingFor in PID file → summary is just the last user message
+            expect(agents[0].summary).toBe('hello');
+
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
+        it('should fall back to JSONL-derived status when PID-file status is missing or unrecognized', async () => {
+            const startTime = new Date();
+            const processes: ProcessInfo[] = [
+                { pid: 55052, command: 'claude', cwd: '/project/legacy', tty: 'ttys001', startTime },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+
+            const tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'claude-pid-nostat-'));
+            const sessionsDir = path.join(tmpDir, 'sessions');
+            const projectsDir = path.join(tmpDir, 'projects');
+            const projDir = path.join(projectsDir, '-project-legacy');
+            fs.mkdirSync(sessionsDir, { recursive: true });
+            fs.mkdirSync(projDir, { recursive: true });
+
+            const sessionId = 'legacy-session';
+            const jsonlPath = path.join(projDir, `${sessionId}.jsonl`);
+            // Last entry is assistant → JSONL parser yields WAITING.
+            fs.writeFileSync(jsonlPath, [
+                JSON.stringify({ type: 'user', timestamp: new Date().toISOString(), cwd: '/project/legacy', message: { content: 'do the thing' } }),
+                JSON.stringify({ type: 'assistant', timestamp: new Date().toISOString() }),
+            ].join('\n'));
+
+            // PID file with unrecognized status string — adapter must ignore it and use parser
+            fs.writeFileSync(
+                path.join(sessionsDir, '55052.json'),
+                JSON.stringify({
+                    pid: 55052, sessionId, cwd: '/project/legacy',
+                    startedAt: startTime.getTime(),
+                    kind: 'interactive', entrypoint: 'cli',
+                    status: 'fantastical-future-state',
+                }),
+            );
+
+            (adapter as any).sessionsDir = sessionsDir;
+            (adapter as any).projectsDir = projectsDir;
+
+            const agents = await adapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0].status).toBe(AgentStatus.WAITING);
+
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
+        it('should pick up live status from PID file even when matched via --resume', async () => {
+            const sessionId = 'aaaaaaaa-1111-2222-3333-444444444444';
+            const startTime = new Date();
+            const processes: ProcessInfo[] = [
+                {
+                    pid: 55053,
+                    command: `claude --resume ${sessionId}`,
+                    cwd: '/project/resume-wait',
+                    tty: 'ttys001',
+                    startTime,
+                },
+            ];
+            mockedListAgentProcesses.mockReturnValue(processes);
+            mockedEnrichProcesses.mockReturnValue(processes);
+
+            const tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'claude-resume-wait-'));
+            const sessionsDir = path.join(tmpDir, 'sessions');
+            const projectsDir = path.join(tmpDir, 'projects');
+            const projDir = path.join(projectsDir, '-project-resume-wait');
+            fs.mkdirSync(sessionsDir, { recursive: true });
+            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/resume-wait', message: { content: 'resumed work' } }),
+                JSON.stringify({ type: 'permission-mode', timestamp: new Date().toISOString(), permissionMode: 'default' }),
+            ].join('\n'));
+
+            fs.writeFileSync(
+                path.join(sessionsDir, '55053.json'),
+                JSON.stringify({
+                    pid: 55053, sessionId, cwd: '/project/resume-wait',
+                    startedAt: startTime.getTime(),
+                    kind: 'interactive', entrypoint: 'cli',
+                    status: 'waiting', waitingFor: 'approve Bash',
+                }),
+            );
+
+            (adapter as any).sessionsDir = sessionsDir;
+            (adapter as any).projectsDir = projectsDir;
+
+            const agents = await adapter.detectAgents();
+
+            expect(agents).toHaveLength(1);
+            expect(agents[0].status).toBe(AgentStatus.WAITING);
+            expect(agents[0].summary).toContain('resumed work');
+            expect(agents[0].summary).toContain('waiting for approve Bash');
+
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        });
+
         it('should fall back to process-only when direct-matched JSONL becomes unreadable', async () => {
             const startTime = new Date();
             const processes: ProcessInfo[] = [
@@ -844,7 +1102,7 @@ describe('ClaudeCodeAdapter', () => {
             };
 
             const writeJsonl = (cwd: string, sessionId: string) => {
-                const encoded = cwd.replace(/\//g, '-');
+                const encoded = cwd.replace(/[^a-zA-Z0-9]/g, '-');
                 const projDir = path.join(projectsDir, encoded);
                 fs.mkdirSync(projDir, { recursive: true });
                 const filePath = path.join(projDir, `${sessionId}.jsonl`);
@@ -979,6 +1237,44 @@ describe('ClaudeCodeAdapter', () => {
             });
         });
 
+        describe('getProjectDir', () => {
+            const encode = (cwd: string) => (adapter as any).getProjectDir(cwd) as string;
+
+            it('should replace path separators with hyphens', () => {
+                const expected = path.join((adapter as any).projectsDir, '-Users-foo-bar');
+                expect(encode('/Users/foo/bar')).toBe(expected);
+            });
+
+            it('should encode underscores as hyphens (matches Claude Code CLI)', () => {
+                const expected = path.join((adapter as any).projectsDir, '-Users-foo-my-project');
+                expect(encode('/Users/foo/my_project')).toBe(expected);
+            });
+
+            it('should encode dots as hyphens', () => {
+                const expected = path.join((adapter as any).projectsDir, '-Users-foo--worktrees-x');
+                expect(encode('/Users/foo/.worktrees/x')).toBe(expected);
+            });
+
+            it('should collide paths that differ only in non-alphanumeric chars', () => {
+                // The encoding is intentionally lossy — callers must
+                // disambiguate via session JSONL contents, not dir name.
+                expect(encode('/a/b_c')).toBe(encode('/a/b-c'));
+                expect(encode('/a/b_c')).toBe(encode('/a/b.c'));
+            });
+
+            it('should resolve to a real session dir when cwd contains underscores', () => {
+                const cwd = '/Users/foo/my_project';
+                const projectsDir = (adapter as any).projectsDir as string;
+                const expectedDir = path.join(projectsDir, '-Users-foo-my-project');
+                fs.mkdirSync(expectedDir, { recursive: true });
+                const sessionFile = path.join(expectedDir, 'session-underscore.jsonl');
+                fs.writeFileSync(sessionFile, '');
+
+                expect(encode(cwd)).toBe(expectedDir);
+                expect(fs.existsSync(path.join(encode(cwd), 'session-underscore.jsonl'))).toBe(true);
+            });
+        });
+
         describe('readSession', () => {
             it('should parse session file with timestamps, cwd, and entry type', () => {
                 const readSession = (adapter as any).parser.readSession.bind((adapter as any).parser);