@ai-devkit/agent-manager 0.33.0 → 0.33.1

package/src/__tests__/AgentManager.test.ts

@@ -16,6 +16,7 @@ import type {
 } from "../adapters/AgentAdapter.js";
 import { AgentStatus } from "../adapters/AgentAdapter.js";
 import { AgentRegistry, type RegistryEntry } from "../utils/AgentRegistry.js";
+import type { HerdrAgentPane } from "../runtime/herdr/HerdrAgentDiscovery.js";
 
 // Mock adapter for testing
 class MockAdapter implements AgentAdapter {
@@ -360,6 +361,15 @@ describe("AgentManager", () => {
       fs.rmSync(tmpDir, { recursive: true, force: true });
     });
 
+    function useHerdrPanes(panes: readonly HerdrAgentPane[]): ReturnType<typeof vi.fn> {
+      const fetchHerdrPanes = vi.fn().mockResolvedValue(panes);
+      scopedManager = new AgentManager(registry, undefined, {
+        runtimeProvider: "herdr",
+        fetchHerdrAgentPanes: fetchHerdrPanes,
+      });
+      return fetchHerdrPanes;
+    }
+
     it("persists every detected agent to the registry", async () => {
       scopedManager.registerAdapter(
         new MockAdapter("claude", [
@@ -390,6 +400,223 @@ describe("AgentManager", () => {
       expect(entries[0].startedAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
     });
 
+    it("persists a Herdr runtime ref for manually discovered agents matched by session id", async () => {
+      useHerdrPanes([
+        {
+          agent: "codex",
+          agentSessionId: "01a0a05e-751f-7850-9fd7-247e297f9ac5",
+          cwd: "/cwd/ai-devkit",
+          paneId: "w31:p1",
+          workspaceId: "w31",
+          tabId: "w31:t1",
+        },
+      ]);
+      scopedManager.registerAdapter(
+        new MockAdapter("codex", [
+          createMockAgent({
+            name: "ai-devkit-44290",
+            type: "codex",
+            pid: process.pid,
+            sessionId: "01a0a05e-751f-7850-9fd7-247e297f9ac5",
+            sessionFilePath: "/path/codex.jsonl",
+            projectPath: "/cwd/ai-devkit",
+          }),
+        ]),
+      );
+
+      await scopedManager.listAgents();
+
+      expect(registry.list()[0]).toMatchObject({
+        name: "ai-devkit-44290",
+        type: "codex",
+        pid: process.pid,
+        runtime: "herdr",
+        runtimeRef: {
+          session: "default",
+          paneId: "w31:p1",
+          workspaceId: "w31",
+          tabId: "w31:t1",
+          agentName: "ai-devkit-44290",
+        },
+      });
+    });
+
+    it("upgrades an existing tmux fallback row when Herdr later matches by session id", async () => {
+      useHerdrPanes([
+        {
+          agent: "codex",
+          agentSessionId: "01a0a05e-751f-7850-9fd7-247e297f9ac5",
+          cwd: "/cwd/ai-devkit",
+          paneId: "w31:p1",
+        },
+      ]);
+      registry.register({
+        name: "ai-devkit-44290",
+        type: "codex",
+        pid: process.pid,
+        runtime: "tmux",
+        runtimeRef: null,
+        cwd: "/cwd/ai-devkit",
+        startedAt: "2026-09-14T00:00:00.000Z",
+        sessionId: "01a0a05e-751f-7850-9fd7-247e297f9ac5",
+        sessionFilePath: "/path/codex.jsonl",
+      });
+      scopedManager.registerAdapter(
+        new MockAdapter("codex", [
+          createMockAgent({
+            name: "ai-devkit-44290",
+            type: "codex",
+            pid: process.pid,
+            sessionId: "01a0a05e-751f-7850-9fd7-247e297f9ac5",
+            sessionFilePath: "/path/codex.jsonl",
+            projectPath: "/cwd/ai-devkit",
+          }),
+        ]),
+      );
+
+      await scopedManager.listAgents();
+
+      expect(registry.lookup("ai-devkit-44290")).toMatchObject({
+        runtime: "herdr",
+        runtimeRef: {
+          session: "default",
+          paneId: "w31:p1",
+          agentName: "ai-devkit-44290",
+        },
+      });
+    });
+
+    it("upgrades an existing tmux fallback row when Herdr matches by foreground pid", async () => {
+      useHerdrPanes([
+        {
+          agent: "codex",
+          cwd: "/cwd/ai-devkit",
+          paneId: "w31:p1",
+          foregroundPids: [44290],
+        },
+        {
+          agent: "codex",
+          cwd: "/cwd/ai-devkit",
+          paneId: "w32:p1",
+          foregroundPids: [process.pid],
+        },
+      ]);
+      registry.register({
+        name: "ai-devkit-64904",
+        type: "codex",
+        pid: process.pid,
+        runtime: "tmux",
+        runtimeRef: null,
+        cwd: "/cwd/ai-devkit",
+        startedAt: "2026-09-14T00:00:00.000Z",
+        sessionId: `pid-${process.pid}`,
+        sessionFilePath: "",
+      });
+      scopedManager.registerAdapter(
+        new MockAdapter("codex", [
+          createMockAgent({
+            name: "ai-devkit-64904",
+            type: "codex",
+            pid: process.pid,
+            sessionId: `pid-${process.pid}`,
+            sessionFilePath: undefined,
+            projectPath: "/cwd/ai-devkit",
+          }),
+        ]),
+      );
+
+      await scopedManager.listAgents();
+
+      expect(registry.lookup("ai-devkit-64904")).toMatchObject({
+        runtime: "herdr",
+        runtimeRef: {
+          session: "default",
+          paneId: "w32:p1",
+          agentName: "ai-devkit-64904",
+        },
+      });
+    });
+
+    it("fetches Herdr panes automatically when the configured runtime is Herdr", async () => {
+      const fetchHerdrPanes = useHerdrPanes([
+        {
+          agent: "codex",
+          cwd: "/cwd/ai-devkit",
+          paneId: "w32:p1",
+          foregroundPids: [process.pid],
+        },
+      ]);
+      scopedManager.registerAdapter(
+        new MockAdapter("codex", [
+          createMockAgent({
+            name: "ai-devkit-64904",
+            type: "codex",
+            pid: process.pid,
+            sessionId: `pid-${process.pid}`,
+            sessionFilePath: undefined,
+            projectPath: "/cwd/ai-devkit",
+          }),
+        ]),
+      );
+
+      await scopedManager.listAgents();
+
+      expect(fetchHerdrPanes).toHaveBeenCalledOnce();
+      expect(registry.lookup("ai-devkit-64904")).toMatchObject({
+        runtime: "herdr",
+        runtimeRef: {
+          session: "default",
+          paneId: "w32:p1",
+          agentName: "ai-devkit-64904",
+        },
+      });
+    });
+
+    it("upgrades an existing tmux row with a malformed runtime ref when Herdr matches", async () => {
+      useHerdrPanes([
+        {
+          agent: "codex",
+          cwd: "/cwd/ai-devkit",
+          paneId: "w32:p1",
+          foregroundPids: [process.pid],
+        },
+      ]);
+      registry.register({
+        name: "ai-devkit-64904",
+        type: "codex",
+        pid: process.pid,
+        runtime: "tmux",
+        runtimeRef: {},
+        cwd: "/cwd/ai-devkit",
+        startedAt: "2026-09-14T00:00:00.000Z",
+        sessionId: `pid-${process.pid}`,
+        sessionFilePath: "",
+      });
+      scopedManager.registerAdapter(
+        new MockAdapter("codex", [
+          createMockAgent({
+            name: "ai-devkit-64904",
+            type: "codex",
+            pid: process.pid,
+            sessionId: `pid-${process.pid}`,
+            sessionFilePath: undefined,
+            projectPath: "/cwd/ai-devkit",
+          }),
+        ]),
+      );
+
+      await scopedManager.listAgents();
+
+      expect(registry.lookup("ai-devkit-64904")).toMatchObject({
+        runtime: "herdr",
+        runtimeRef: {
+          session: "default",
+          paneId: "w32:p1",
+          agentName: "ai-devkit-64904",
+        },
+      });
+    });
+
     it("prunes entries for dead pids", async () => {
       registry.register({
         name: "dead",
@@ -620,7 +847,7 @@ describe("AgentManager", () => {
       expect(agents[0].lastActive.toISOString()).toBe("2026-01-01T00:00:00.000Z");
     });
 
-    it("persists changed fields once in one write transaction", async () => {
+    it("does not persist passive cwd changes when an existing cwd is present", async () => {
       const adapter = new MockAdapter("claude", [
         createMockAgent({ name: "changing", pid: process.pid, projectPath: "/cwd/before" }),
       ]);
@@ -636,10 +863,9 @@ describe("AgentManager", () => {
 
       const upserts = databaseOperations.filter((sql) => /^\s*INSERT INTO agents/i.test(sql));
       const transactions = databaseOperations.filter((sql) => /^\s*(BEGIN|COMMIT)/i.test(sql));
-      expect(upserts).toHaveLength(1);
-      expect(upserts[0]).toContain("'2026-08-14T10:00:01.000Z'");
-      expect(transactions).toHaveLength(2);
-      expect(registry.lookup("changing")?.cwd).toBe("/cwd/after");
+      expect(upserts).toHaveLength(0);
+      expect(transactions).toHaveLength(0);
+      expect(registry.lookup("changing")?.cwd).toBe("/cwd/before");
     });
 
     it("prunes newly dead entries only when the passive cadence is due", async () => {

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

@@ -141,6 +141,7 @@ describe("OpenCodeAdapter", () => {
   });
 
   afterEach(() => {
+    adapter.close();
     fs.rmSync(tmpDir, { recursive: true, force: true });
     vi.restoreAllMocks();
   });

package/src/__tests__/{adapters → providers/copilot}/CopilotAdapter.test.ts

@@ -7,19 +7,19 @@ import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
 
-import { CopilotAdapter } from "../../adapters/CopilotAdapter.js";
-import type { ProcessInfo } from "../../adapters/AgentAdapter.js";
-import { AgentStatus } from "../../adapters/AgentAdapter.js";
+import { CopilotAdapter } from "../../../providers/copilot/CopilotAdapter.js";
+import type { ProcessInfo } from "../../../adapters/AgentAdapter.js";
+import { AgentStatus } from "../../../adapters/AgentAdapter.js";
 import {
   listAgentProcesses,
   enrichProcesses,
   captureProcessSnapshot,
-} from "../../utils/process.js";
-import { generateAgentName } from "../../utils/matching.js";
-import { AgentRegistry } from "../../utils/AgentRegistry.js";
+} from "../../../utils/process.js";
+import { generateAgentName } from "../../../utils/matching.js";
+import { AgentRegistry } from "../../../utils/AgentRegistry.js";
 
-vi.mock("../../utils/process.js", async (importOriginal) => {
-  const actual = (await importOriginal()) as typeof import("../../utils/process.js");
+vi.mock("../../../utils/process.js", async (importOriginal) => {
+  const actual = (await importOriginal()) as typeof import("../../../utils/process.js");
   return {
     ...actual,
     listAgentProcesses: vi.fn(),
@@ -28,7 +28,7 @@ vi.mock("../../utils/process.js", async (importOriginal) => {
   };
 });
 
-vi.mock("../../utils/matching.js", () => ({
+vi.mock("../../../utils/matching.js", () => ({
   generateAgentName: vi.fn(),
 }));
 
@@ -45,11 +45,10 @@ describe("CopilotAdapter", () => {
   let sessionStateDir: string;
 
   beforeEach(() => {
-    adapter = new CopilotAdapter();
     tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "copilot-test-"));
     sessionStateDir = path.join(tmpDir, "session-state");
     fs.mkdirSync(sessionStateDir, { recursive: true });
-    (adapter as any).sessionStateDir = sessionStateDir;
+    adapter = new CopilotAdapter(undefined, { sessionStateDir });
 
     mockedListAgentProcesses.mockReset();
     mockedEnrichProcesses.mockReset();
@@ -296,8 +295,7 @@ describe("CopilotAdapter", () => {
 
     it("carries the managed wrapper name to a process-only child before the session lock exists", async () => {
       const registry = new AgentRegistry(path.join(tmpDir, "agents.json"));
-      adapter = new CopilotAdapter(registry);
-      (adapter as any).sessionStateDir = sessionStateDir;
+      adapter = new CopilotAdapter(registry, { sessionStateDir });
       const processes: ProcessInfo[] = [
         { pid: 86800, command: "copilot", cwd: "/repo", tty: "ttys001", ppid: 84174 },
         {
@@ -363,8 +361,7 @@ describe("CopilotAdapter", () => {
 
     it("carries the managed wrapper name to a lock-backed child process", async () => {
       const registry = new AgentRegistry(path.join(tmpDir, "agents.json"));
-      adapter = new CopilotAdapter(registry);
-      (adapter as any).sessionStateDir = sessionStateDir;
+      adapter = new CopilotAdapter(registry, { sessionStateDir });
       const processes: ProcessInfo[] = [
         { pid: 14095, command: "copilot", cwd: "/repo", tty: "ttys001", ppid: 84174 },
         {
@@ -597,7 +594,7 @@ describe("CopilotAdapter", () => {
     });
 
     it("returns empty when session-state directory does not exist", async () => {
-      (adapter as any).sessionStateDir = path.join(tmpDir, "missing");
+      adapter = new CopilotAdapter(undefined, { sessionStateDir: path.join(tmpDir, "missing") });
 
       await expect(adapter.listSessions()).resolves.toEqual([]);
     });

package/src/__tests__/{adapters → providers/gemini}/GeminiCliAdapter.test.ts

@@ -7,20 +7,22 @@ import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
 
-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 { GeminiCliAdapter } from "../../../providers/gemini/GeminiCliAdapter.js";
+import { GeminiSessionLocator } from "../../../providers/gemini/GeminiSessionLocator.js";
+import { GeminiSessionParser } from "../../../providers/gemini/GeminiSessionParser.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,
   captureProcessSnapshot,
-} from "../../utils/process.js";
-import { matchProcessesToSessions, generateAgentName } from "../../utils/matching.js";
+} from "../../../utils/process.js";
+import { matchProcessesToSessions, generateAgentName } from "../../../utils/matching.js";
 import * as crypto from "crypto";
 
-vi.mock("../../utils/process.js", async (importOriginal) => {
-  const actual = (await importOriginal()) as typeof import("../../utils/process.js");
+vi.mock("../../../utils/process.js", async (importOriginal) => {
+  const actual = (await importOriginal()) as typeof import("../../../utils/process.js");
   return {
     ...actual,
     listAgentProcesses: vi.fn(),
@@ -29,7 +31,7 @@ vi.mock("../../utils/process.js", async (importOriginal) => {
   };
 });
 
-vi.mock("../../utils/matching.js", () => ({
+vi.mock("../../../utils/matching.js", () => ({
   matchProcessesToSessions: vi.fn(),
   generateAgentName: vi.fn(),
 }));
@@ -47,12 +49,18 @@ const mockedGenerateAgentName = generateAgentName as MockedFunction<typeof gener
 describe("GeminiCliAdapter", () => {
   let adapter: GeminiCliAdapter;
   let tmpHome: string;
+  let parser: GeminiSessionParser;
+  let locator: GeminiSessionLocator;
 
   beforeEach(() => {
     tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "gemini-adapter-test-"));
     process.env.HOME = tmpHome;
 
     adapter = new GeminiCliAdapter(new AgentRegistry(path.join(tmpHome, "agents.json")));
+    parser = new GeminiSessionParser();
+    locator = new GeminiSessionLocator({
+      geminiTmpDir: path.join(tmpHome, ".gemini", "tmp"),
+    });
     mockedListAgentProcesses.mockReset();
     mockedEnrichProcesses.mockReset();
     mockedCaptureProcessSnapshot.mockReset();
@@ -621,7 +629,7 @@ describe("GeminiCliAdapter", () => {
         startTime: new Date(),
       };
       // tmp dir absent by default
-      const result = (adapter as any).discoverSessions([proc]);
+      const result = locator.discoverSessions([proc]);
       expect(result.sessions).toEqual([]);
       expect(result.contentCache.size).toBe(0);
     });
@@ -643,7 +651,7 @@ describe("GeminiCliAdapter", () => {
         messages: [],
       });
 
-      const result = (adapter as any).discoverSessions([proc]);
+      const result = locator.discoverSessions([proc]);
       expect(result.sessions).toEqual([]);
     });
 
@@ -664,7 +672,7 @@ describe("GeminiCliAdapter", () => {
         messages: [],
       });
 
-      const result = (adapter as any).discoverSessions([proc]);
+      const result = locator.discoverSessions([proc]);
       expect(result.sessions).toEqual([]);
     });
 
@@ -690,7 +698,7 @@ describe("GeminiCliAdapter", () => {
         messages: [],
       });
 
-      const result = (adapter as any).discoverSessions([proc]);
+      const result = locator.discoverSessions([proc]);
       expect(result.sessions).toHaveLength(1);
       expect(result.sessions[0].sessionId).toBe("s-good");
     });
@@ -716,7 +724,7 @@ describe("GeminiCliAdapter", () => {
         messages: [],
       });
 
-      const result = (adapter as any).discoverSessions([proc]);
+      const result = locator.discoverSessions([proc]);
       expect(result.sessions).toHaveLength(1);
       expect(result.sessions[0].resolvedCwd).toBe(procCwd);
     });
@@ -742,12 +750,12 @@ describe("GeminiCliAdapter", () => {
         }),
       );
 
-      const result = (adapter as any).discoverSessions([proc]);
+      const result = locator.discoverSessions([proc]);
       expect(result.sessions).toEqual([]);
     });
   });
 
-  describe("helper methods", () => {
+  describe("GeminiSessionParser", () => {
     describe("determineStatus", () => {
       it('should return "waiting" when the last message is from gemini', () => {
         const session = {
@@ -758,7 +766,7 @@ describe("GeminiCliAdapter", () => {
           lastActive: new Date(),
           lastMessageType: "gemini",
         };
-        expect((adapter as any).determineStatus(session)).toBe(AgentStatus.WAITING);
+        expect(parser.determineStatus(session)).toBe(AgentStatus.WAITING);
       });
 
       it('should return "waiting" when the last message is from assistant', () => {
@@ -770,7 +778,7 @@ describe("GeminiCliAdapter", () => {
           lastActive: new Date(),
           lastMessageType: "assistant",
         };
-        expect((adapter as any).determineStatus(session)).toBe(AgentStatus.WAITING);
+        expect(parser.determineStatus(session)).toBe(AgentStatus.WAITING);
       });
 
       it('should return "running" when the last message is from the user', () => {
@@ -782,7 +790,7 @@ describe("GeminiCliAdapter", () => {
           lastActive: new Date(),
           lastMessageType: "user",
         };
-        expect((adapter as any).determineStatus(session)).toBe(AgentStatus.RUNNING);
+        expect(parser.determineStatus(session)).toBe(AgentStatus.RUNNING);
       });
 
       it('should return "idle" when last activity is older than the threshold', () => {
@@ -794,7 +802,7 @@ describe("GeminiCliAdapter", () => {
           lastActive: new Date(Date.now() - 10 * 60 * 1000),
           lastMessageType: "gemini",
         };
-        expect((adapter as any).determineStatus(session)).toBe(AgentStatus.IDLE);
+        expect(parser.determineStatus(session)).toBe(AgentStatus.IDLE);
       });
     });
 
@@ -812,7 +820,7 @@ describe("GeminiCliAdapter", () => {
           ],
         });
 
-        const result = (adapter as any).parseSession(undefined, filePath);
+        const result = parser.parseSession(undefined, filePath);
         expect(result).toMatchObject({
           sessionId: "s1",
           projectPath: "/repo",
@@ -829,24 +837,24 @@ describe("GeminiCliAdapter", () => {
           messages: [],
         });
 
-        const result = (adapter as any).parseSession(content, "/does/not/exist.json");
+        const result = parser.parseSession(content, "/does/not/exist.json");
         expect(result?.sessionId).toBe("s2");
       });
 
       it("should return null for a missing file with no cached content", () => {
-        expect((adapter as any).parseSession(undefined, "/missing.json")).toBeNull();
+        expect(parser.parseSession(undefined, "/missing.json")).toBeNull();
       });
 
       it("should return null when the file is not valid JSON", () => {
         const filePath = path.join(tmpHome, "broken.json");
         fs.writeFileSync(filePath, "not json");
-        expect((adapter as any).parseSession(undefined, filePath)).toBeNull();
+        expect(parser.parseSession(undefined, filePath)).toBeNull();
       });
 
       it("should return null when sessionId is missing", () => {
         const filePath = path.join(tmpHome, "no-id.json");
         fs.writeFileSync(filePath, JSON.stringify({ messages: [] }));
-        expect((adapter as any).parseSession(undefined, filePath)).toBeNull();
+        expect(parser.parseSession(undefined, filePath)).toBeNull();
       });
 
       it("should default the summary when no user message has content", () => {
@@ -865,7 +873,7 @@ describe("GeminiCliAdapter", () => {
           ],
         });
 
-        const result = (adapter as any).parseSession(undefined, filePath);
+        const result = parser.parseSession(undefined, filePath);
         expect(result?.summary).toBe("Gemini CLI session active");
       });
 
@@ -881,7 +889,7 @@ describe("GeminiCliAdapter", () => {
           ],
         });
 
-        const result = (adapter as any).parseSession(undefined, filePath);
+        const result = parser.parseSession(undefined, filePath);
         expect(result?.summary.length).toBe(120);
         expect(result?.summary.endsWith("...")).toBe(true);
       });
@@ -902,7 +910,7 @@ describe("GeminiCliAdapter", () => {
           ],
         });
 
-        const result = (adapter as any).parseSession(undefined, filePath);
+        const result = parser.parseSession(undefined, filePath);
         expect(result?.summary).toBe("hello from part continued");
       });
 
@@ -922,7 +930,7 @@ describe("GeminiCliAdapter", () => {
           ],
         });
 
-        expect(() => (adapter as any).parseSession(undefined, filePath)).not.toThrow();
+        expect(() => parser.parseSession(undefined, filePath)).not.toThrow();
       });
 
       it("should drop non-text parts (data/file) when resolving user content", () => {
@@ -945,7 +953,7 @@ describe("GeminiCliAdapter", () => {
           ],
         });
 
-        const result = (adapter as any).parseSession(undefined, filePath);
+        const result = parser.parseSession(undefined, filePath);
         expect(result?.summary).toBe("readable text + more");
       });
 
@@ -958,7 +966,7 @@ describe("GeminiCliAdapter", () => {
           messages: [{ id: "m1", timestamp: "2026-04-18T00:00:01Z", type: "user", content: "hi" }],
         });
 
-        const result = (adapter as any).parseSession(undefined, filePath);
+        const result = parser.parseSession(undefined, filePath);
         expect(result?.lastActive.toISOString()).toBe("2026-04-18T00:10:00.000Z");
       });
     });