@ai-devkit/agent-manager 0.32.0 → 0.33.1

package/dist/__tests__/providers/claude/ClaudeSessionLocator.test.js

@@ -1,11 +1,11 @@
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { AgentStatus } from '../../../adapters/AgentAdapter.js';
-import { ClaudeSessionLocator } from '../../../providers/claude/ClaudeSessionLocator.js';
-import { batchGetSessionFileBirthtimes } from '../../../utils/session.js';
-vi.mock('../../../utils/session.js', async (importOriginal)=>{
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { AgentStatus } from "../../../adapters/AgentAdapter.js";
+import { ClaudeSessionLocator } from "../../../providers/claude/ClaudeSessionLocator.js";
+import { batchGetSessionFileBirthtimes } from "../../../utils/session.js";
+vi.mock("../../../utils/session.js", async (importOriginal)=>{
     const actual = await importOriginal();
     return {
         ...actual,
@@ -15,17 +15,17 @@ vi.mock('../../../utils/session.js', async (importOriginal)=>{
 const mockedBatchGetSessionFileBirthtimes = batchGetSessionFileBirthtimes;
 const tmpDirs = [];
 function makeTmpDir() {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-locator-test-'));
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "claude-locator-test-"));
     tmpDirs.push(dir);
     return dir;
 }
 function makeProcess(overrides = {}) {
     return {
         pid: 123,
-        command: 'claude',
-        cwd: '/repo/my-app',
-        tty: 'ttys001',
-        startTime: new Date('2026-08-23T10:00:00.000Z'),
+        command: "claude",
+        cwd: "/repo/my-app",
+        tty: "ttys001",
+        startTime: new Date("2026-08-23T10:00:00.000Z"),
         ...overrides
     };
 }
@@ -35,7 +35,7 @@ function makeProcess(overrides = {}) {
 /** `getProjectDir` is private; bound here so the encoding tests read cleanly. */ function bindProjectDir(locator) {
     return locator.getProjectDir.bind(locator);
 }
-describe('ClaudeSessionLocator', ()=>{
+describe("ClaudeSessionLocator", ()=>{
     beforeEach(()=>{
         mockedBatchGetSessionFileBirthtimes.mockReset();
     });
@@ -47,13 +47,13 @@ describe('ClaudeSessionLocator', ()=>{
             });
         }
     });
-    it('matches resumed sessions directly and carries live PID status metadata', ()=>{
+    it("matches resumed sessions directly and carries live PID status metadata", ()=>{
         const root = makeTmpDir();
-        const projectsDir = path.join(root, 'projects');
-        const sessionsDir = path.join(root, 'sessions');
-        const cwd = '/repo/my-app';
-        const sessionId = '12345678-1234-1234-1234-123456789abc';
-        const projectDir = path.join(projectsDir, '-repo-my-app');
+        const projectsDir = path.join(root, "projects");
+        const sessionsDir = path.join(root, "sessions");
+        const cwd = "/repo/my-app";
+        const sessionId = "12345678-1234-1234-1234-123456789abc";
+        const projectDir = path.join(projectsDir, "-repo-my-app");
         const sessionFile = path.join(projectDir, `${sessionId}.jsonl`);
         fs.mkdirSync(projectDir, {
             recursive: true
@@ -61,16 +61,16 @@ describe('ClaudeSessionLocator', ()=>{
         fs.mkdirSync(sessionsDir, {
             recursive: true
         });
-        fs.writeFileSync(sessionFile, '{}\n');
-        fs.writeFileSync(path.join(sessionsDir, '123.json'), JSON.stringify({
+        fs.writeFileSync(sessionFile, "{}\n");
+        fs.writeFileSync(path.join(sessionsDir, "123.json"), JSON.stringify({
             pid: 123,
             sessionId,
             cwd,
-            startedAt: new Date('2026-08-23T10:00:00.000Z').getTime(),
-            kind: 'interactive',
-            entrypoint: 'cli',
-            status: 'waiting',
-            waitingFor: 'approve Read'
+            startedAt: new Date("2026-08-23T10:00:00.000Z").getTime(),
+            kind: "interactive",
+            entrypoint: "cli",
+            status: "waiting",
+            waitingFor: "approve Read"
         }));
         const locator = new ClaudeSessionLocator({
             projectsDir,
@@ -86,7 +86,7 @@ describe('ClaudeSessionLocator', ()=>{
         expect(matches.legacyMatches).toEqual([]);
         expect(matches.direct[0]).toMatchObject({
             pidStatus: AgentStatus.WAITING,
-            waitingFor: 'approve Read',
+            waitingFor: "approve Read",
             sessionFile: {
                 sessionId,
                 filePath: sessionFile,
@@ -95,72 +95,72 @@ describe('ClaudeSessionLocator', ()=>{
             }
         });
     });
-    describe('discoverLiveSessions', ()=>{
+    describe("discoverLiveSessions", ()=>{
         let tmpDir;
         let projectsDir;
         let locator;
         beforeEach(()=>{
             tmpDir = makeTmpDir();
-            projectsDir = path.join(tmpDir, 'projects');
+            projectsDir = path.join(tmpDir, "projects");
             locator = new ClaudeSessionLocator({
                 projectsDir,
-                sessionsDir: path.join(tmpDir, 'sessions')
+                sessionsDir: path.join(tmpDir, "sessions")
             });
         });
-        it('should return empty when projects dir does not exist', ()=>{
+        it("should return empty when projects dir does not exist", ()=>{
             const missing = new ClaudeSessionLocator({
-                projectsDir: path.join(tmpDir, 'nonexistent'),
-                sessionsDir: path.join(tmpDir, 'sessions')
+                projectsDir: path.join(tmpDir, "nonexistent"),
+                sessionsDir: path.join(tmpDir, "sessions")
             });
             const result = missing.discoverLiveSessions([
                 {
                     pid: 1,
-                    command: 'claude',
-                    cwd: '/test',
-                    tty: ''
+                    command: "claude",
+                    cwd: "/test",
+                    tty: ""
                 }
             ]);
             expect(result).toEqual([]);
         });
-        it('should scan only directories matching process CWDs', ()=>{
+        it("should scan only directories matching process CWDs", ()=>{
             // /my/project → -my-project (encoded dir)
-            const encodedDir = path.join(projectsDir, '-my-project');
+            const encodedDir = path.join(projectsDir, "-my-project");
             fs.mkdirSync(encodedDir, {
                 recursive: true
             });
             // Also create another dir that should NOT be scanned
-            const otherDir = path.join(projectsDir, '-other-project');
+            const otherDir = path.join(projectsDir, "-other-project");
             fs.mkdirSync(otherDir, {
                 recursive: true
             });
             const mockFiles = [
                 {
-                    sessionId: 's1',
-                    filePath: path.join(encodedDir, 's1.jsonl'),
+                    sessionId: "s1",
+                    filePath: path.join(encodedDir, "s1.jsonl"),
                     projectDir: encodedDir,
                     birthtimeMs: 1710800324000,
-                    resolvedCwd: ''
+                    resolvedCwd: ""
                 }
             ];
             mockedBatchGetSessionFileBirthtimes.mockReturnValue(mockFiles);
             const processes = [
                 {
                     pid: 1,
-                    command: 'claude',
-                    cwd: '/my/project',
-                    tty: ''
+                    command: "claude",
+                    cwd: "/my/project",
+                    tty: ""
                 }
             ];
             const result = locator.discoverLiveSessions(processes);
             expect(result).toHaveLength(1);
-            expect(result[0].resolvedCwd).toBe('/my/project');
+            expect(result[0].resolvedCwd).toBe("/my/project");
             // batchGetSessionFileBirthtimes called once with all dirs
             expect(mockedBatchGetSessionFileBirthtimes).toHaveBeenCalledTimes(1);
             expect(mockedBatchGetSessionFileBirthtimes).toHaveBeenCalledWith([
                 encodedDir
             ]);
         });
-        it('should return empty when encoded dir does not exist', ()=>{
+        it("should return empty when encoded dir does not exist", ()=>{
             fs.mkdirSync(projectsDir, {
                 recursive: true
             });
@@ -168,40 +168,40 @@ describe('ClaudeSessionLocator', ()=>{
             const result = locator.discoverLiveSessions([
                 {
                     pid: 1,
-                    command: 'claude',
-                    cwd: '/test',
-                    tty: ''
+                    command: "claude",
+                    cwd: "/test",
+                    tty: ""
                 }
             ]);
             expect(result).toEqual([]);
             expect(mockedBatchGetSessionFileBirthtimes).not.toHaveBeenCalled();
         });
-        it('should deduplicate when multiple processes share same CWD', ()=>{
-            const encodedDir = path.join(projectsDir, '-my-project');
+        it("should deduplicate when multiple processes share same CWD", ()=>{
+            const encodedDir = path.join(projectsDir, "-my-project");
             fs.mkdirSync(encodedDir, {
                 recursive: true
             });
             mockedBatchGetSessionFileBirthtimes.mockReturnValue([
                 {
-                    sessionId: 's1',
-                    filePath: path.join(encodedDir, 's1.jsonl'),
+                    sessionId: "s1",
+                    filePath: path.join(encodedDir, "s1.jsonl"),
                     projectDir: encodedDir,
                     birthtimeMs: 1710800324000,
-                    resolvedCwd: ''
+                    resolvedCwd: ""
                 }
             ]);
             const processes = [
                 {
                     pid: 1,
-                    command: 'claude',
-                    cwd: '/my/project',
-                    tty: ''
+                    command: "claude",
+                    cwd: "/my/project",
+                    tty: ""
                 },
                 {
                     pid: 2,
-                    command: 'claude',
-                    cwd: '/my/project',
-                    tty: ''
+                    command: "claude",
+                    cwd: "/my/project",
+                    tty: ""
                 }
             ];
             const result = locator.discoverLiveSessions(processes);
@@ -212,30 +212,30 @@ describe('ClaudeSessionLocator', ()=>{
             ]);
             expect(result).toHaveLength(1);
         });
-        it('should skip processes with empty cwd', ()=>{
+        it("should skip processes with empty cwd", ()=>{
             fs.mkdirSync(projectsDir, {
                 recursive: true
             });
             const result = locator.discoverLiveSessions([
                 {
                     pid: 1,
-                    command: 'claude',
-                    cwd: '',
-                    tty: ''
+                    command: "claude",
+                    cwd: "",
+                    tty: ""
                 }
             ]);
             expect(result).toEqual([]);
         });
     });
-    describe('tryPidFileMatching', ()=>{
+    describe("tryPidFileMatching", ()=>{
         let tmpDir;
         let sessionsDir;
         let projectsDir;
         let tryMatch;
         beforeEach(()=>{
             tmpDir = makeTmpDir();
-            sessionsDir = path.join(tmpDir, 'sessions');
-            projectsDir = path.join(tmpDir, 'projects');
+            sessionsDir = path.join(tmpDir, "sessions");
+            projectsDir = path.join(tmpDir, "projects");
             fs.mkdirSync(sessionsDir, {
                 recursive: true
             });
@@ -244,11 +244,11 @@ describe('ClaudeSessionLocator', ()=>{
                 sessionsDir
             }));
         });
-        const makeProc = (pid, cwd = '/project/test', startTime)=>({
+        const makeProc = (pid, cwd = "/project/test", startTime)=>({
                 pid,
-                command: 'claude',
+                command: "claude",
                 cwd,
-                tty: 'ttys001',
+                tty: "ttys001",
                 startTime
             });
         const writePidFile = (pid, sessionId, cwd, startedAt)=>{
@@ -257,41 +257,41 @@ describe('ClaudeSessionLocator', ()=>{
                 sessionId,
                 cwd,
                 startedAt,
-                kind: 'interactive',
-                entrypoint: 'cli'
+                kind: "interactive",
+                entrypoint: "cli"
             }));
         };
         const writeJsonl = (cwd, sessionId)=>{
-            const encoded = cwd.replace(/[^a-zA-Z0-9]/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`);
             fs.writeFileSync(filePath, JSON.stringify({
-                type: 'assistant',
+                type: "assistant",
                 timestamp: new Date().toISOString()
             }));
             return filePath;
         };
-        it('should return direct match when PID file and JSONL both exist within time tolerance', ()=>{
+        it("should return direct match when PID file and JSONL both exist within time tolerance", ()=>{
             const startTime = new Date();
-            const proc = makeProc(1001, '/project/test', startTime);
-            writePidFile(1001, 'session-abc', '/project/test', startTime.getTime());
-            writeJsonl('/project/test', 'session-abc');
+            const proc = makeProc(1001, "/project/test", startTime);
+            writePidFile(1001, "session-abc", "/project/test", startTime.getTime());
+            writeJsonl("/project/test", "session-abc");
             const { direct, fallback } = tryMatch([
                 proc
             ]);
             expect(direct).toHaveLength(1);
             expect(fallback).toHaveLength(0);
-            expect(direct[0].sessionFile.sessionId).toBe('session-abc');
-            expect(direct[0].sessionFile.resolvedCwd).toBe('/project/test');
+            expect(direct[0].sessionFile.sessionId).toBe("session-abc");
+            expect(direct[0].sessionFile.resolvedCwd).toBe("/project/test");
             expect(direct[0].process.pid).toBe(1001);
         });
-        it('should fall back when PID file exists but JSONL is missing', ()=>{
+        it("should fall back when PID file exists but JSONL is missing", ()=>{
             const startTime = new Date();
-            const proc = makeProc(1002, '/project/test', startTime);
-            writePidFile(1002, 'nonexistent-session', '/project/test', startTime.getTime());
+            const proc = makeProc(1002, "/project/test", startTime);
+            writePidFile(1002, "nonexistent-session", "/project/test", startTime.getTime());
             // No JSONL file written
             const { direct, fallback } = tryMatch([
                 proc
@@ -300,32 +300,32 @@ describe('ClaudeSessionLocator', ()=>{
             expect(fallback).toHaveLength(1);
             expect(fallback[0].pid).toBe(1002);
         });
-        it('should fall back when startedAt is stale (>60s from proc.startTime)', ()=>{
+        it("should fall back when startedAt is stale (>60s from proc.startTime)", ()=>{
             const startTime = new Date();
             const staleTime = startTime.getTime() - 90_000; // 90 seconds earlier
-            const proc = makeProc(1003, '/project/test', startTime);
-            writePidFile(1003, 'stale-session', '/project/test', staleTime);
-            writeJsonl('/project/test', 'stale-session');
+            const proc = makeProc(1003, "/project/test", startTime);
+            writePidFile(1003, "stale-session", "/project/test", staleTime);
+            writeJsonl("/project/test", "stale-session");
             const { direct, fallback } = tryMatch([
                 proc
             ]);
             expect(direct).toHaveLength(0);
             expect(fallback).toHaveLength(1);
         });
-        it('should accept PID file when startedAt is within 60s tolerance', ()=>{
+        it("should accept PID file when startedAt is within 60s tolerance", ()=>{
             const startTime = new Date();
             const closeTime = startTime.getTime() - 30_000; // 30 seconds earlier — within tolerance
-            const proc = makeProc(1004, '/project/test', startTime);
-            writePidFile(1004, 'close-session', '/project/test', closeTime);
-            writeJsonl('/project/test', 'close-session');
+            const proc = makeProc(1004, "/project/test", startTime);
+            writePidFile(1004, "close-session", "/project/test", closeTime);
+            writeJsonl("/project/test", "close-session");
             const { direct, fallback } = tryMatch([
                 proc
             ]);
             expect(direct).toHaveLength(1);
             expect(fallback).toHaveLength(0);
         });
-        it('should fall back when PID file is absent', ()=>{
-            const proc = makeProc(1005, '/project/test', new Date());
+        it("should fall back when PID file is absent", ()=>{
+            const proc = makeProc(1005, "/project/test", new Date());
             // No PID file written
             const { direct, fallback } = tryMatch([
                 proc
@@ -333,9 +333,9 @@ describe('ClaudeSessionLocator', ()=>{
             expect(direct).toHaveLength(0);
             expect(fallback).toHaveLength(1);
         });
-        it('should fall back when PID file contains malformed JSON', ()=>{
-            const proc = makeProc(1006, '/project/test', new Date());
-            fs.writeFileSync(path.join(sessionsDir, '1006.json'), 'not valid json {{{');
+        it("should fall back when PID file contains malformed JSON", ()=>{
+            const proc = makeProc(1006, "/project/test", new Date());
+            fs.writeFileSync(path.join(sessionsDir, "1006.json"), "not valid json {{{");
             expect(()=>{
                 const { direct, fallback } = tryMatch([
                     proc
@@ -344,28 +344,28 @@ describe('ClaudeSessionLocator', ()=>{
                 expect(fallback).toHaveLength(1);
             }).not.toThrow();
         });
-        it('should fall back for all processes when sessions dir does not exist', ()=>{
+        it("should fall back for all processes when sessions dir does not exist", ()=>{
             const missingSessions = bindPidFileMatching(new ClaudeSessionLocator({
                 projectsDir,
-                sessionsDir: path.join(tmpDir, 'nonexistent-sessions')
+                sessionsDir: path.join(tmpDir, "nonexistent-sessions")
             }));
             const processes = [
-                makeProc(2001, '/a', new Date()),
-                makeProc(2002, '/b', new Date())
+                makeProc(2001, "/a", new Date()),
+                makeProc(2002, "/b", new Date())
             ];
             const { direct, fallback } = missingSessions(processes);
             expect(direct).toHaveLength(0);
             expect(fallback).toHaveLength(2);
         });
-        it('should correctly split mixed processes (some with PID files, some without)', ()=>{
+        it("should correctly split mixed processes (some with PID files, some without)", ()=>{
             const startTime = new Date();
-            const proc1 = makeProc(3001, '/project/one', startTime);
-            const proc2 = makeProc(3002, '/project/two', startTime);
-            const proc3 = makeProc(3003, '/project/three', startTime);
-            writePidFile(3001, 'session-one', '/project/one', startTime.getTime());
-            writeJsonl('/project/one', 'session-one');
-            writePidFile(3003, 'session-three', '/project/three', startTime.getTime());
-            writeJsonl('/project/three', 'session-three');
+            const proc1 = makeProc(3001, "/project/one", startTime);
+            const proc2 = makeProc(3002, "/project/two", startTime);
+            const proc3 = makeProc(3003, "/project/three", startTime);
+            writePidFile(3001, "session-one", "/project/one", startTime.getTime());
+            writeJsonl("/project/one", "session-one");
+            writePidFile(3003, "session-three", "/project/three", startTime.getTime());
+            writeJsonl("/project/three", "session-three");
             // proc2 has no PID file
             const { direct, fallback } = tryMatch([
                 proc1,
@@ -380,10 +380,10 @@ describe('ClaudeSessionLocator', ()=>{
             ]);
             expect(fallback[0].pid).toBe(3002);
         });
-        it('should skip stale-file check when proc.startTime is undefined', ()=>{
-            const proc = makeProc(4001, '/project/test', undefined); // no startTime
-            writePidFile(4001, 'no-time-session', '/project/test', Date.now() - 999_999);
-            writeJsonl('/project/test', 'no-time-session');
+        it("should skip stale-file check when proc.startTime is undefined", ()=>{
+            const proc = makeProc(4001, "/project/test", undefined); // no startTime
+            writePidFile(4001, "no-time-session", "/project/test", Date.now() - 999_999);
+            writeJsonl("/project/test", "no-time-session");
             const { direct, fallback } = tryMatch([
                 proc
             ]);
@@ -392,43 +392,43 @@ describe('ClaudeSessionLocator', ()=>{
             expect(fallback).toHaveLength(0);
         });
     });
-    describe('getProjectDir', ()=>{
+    describe("getProjectDir", ()=>{
         let tmpDir;
         let projectsDir;
         let encode;
         beforeEach(()=>{
             tmpDir = makeTmpDir();
-            projectsDir = path.join(tmpDir, 'projects');
+            projectsDir = path.join(tmpDir, "projects");
             encode = bindProjectDir(new ClaudeSessionLocator({
                 projectsDir,
-                sessionsDir: path.join(tmpDir, 'sessions')
+                sessionsDir: path.join(tmpDir, "sessions")
             }));
         });
-        it('should replace path separators with hyphens', ()=>{
-            expect(encode('/Users/foo/bar')).toBe(path.join(projectsDir, '-Users-foo-bar'));
+        it("should replace path separators with hyphens", ()=>{
+            expect(encode("/Users/foo/bar")).toBe(path.join(projectsDir, "-Users-foo-bar"));
         });
-        it('should encode underscores as hyphens (matches Claude Code CLI)', ()=>{
-            expect(encode('/Users/foo/my_project')).toBe(path.join(projectsDir, '-Users-foo-my-project'));
+        it("should encode underscores as hyphens (matches Claude Code CLI)", ()=>{
+            expect(encode("/Users/foo/my_project")).toBe(path.join(projectsDir, "-Users-foo-my-project"));
         });
-        it('should encode dots as hyphens', ()=>{
-            expect(encode('/Users/foo/.worktrees/x')).toBe(path.join(projectsDir, '-Users-foo--worktrees-x'));
+        it("should encode dots as hyphens", ()=>{
+            expect(encode("/Users/foo/.worktrees/x")).toBe(path.join(projectsDir, "-Users-foo--worktrees-x"));
         });
-        it('should collide paths that differ only in non-alphanumeric chars', ()=>{
+        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'));
+            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 expectedDir = path.join(projectsDir, '-Users-foo-my-project');
+        it("should resolve to a real session dir when cwd contains underscores", ()=>{
+            const cwd = "/Users/foo/my_project";
+            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, '');
+            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);
+            expect(fs.existsSync(path.join(encode(cwd), "session-underscore.jsonl"))).toBe(true);
         });
     });
 });