@ai-devkit/agent-manager 0.33.0 → 0.33.1

package/src/__tests__/runtime/HerdrAgentDiscovery.test.ts

@@ -0,0 +1,131 @@
+import {
+  extractHerdrAgentPanes,
+  fetchHerdrAgentPanes,
+  findMatchingHerdrPane,
+} from "../../runtime/herdr/HerdrAgentDiscovery.js";
+import type { HerdrCommandRunner } from "../../runtime/herdr/HerdrCliClient.js";
+
+function jsonResponse(value: unknown): { stdout: string; stderr: string } {
+  return { stdout: JSON.stringify(value), stderr: "" };
+}
+
+describe("HerdrAgentDiscovery", () => {
+  it("extracts agent panes from pane list responses", () => {
+    const panes = extractHerdrAgentPanes({
+      result: {
+        panes: [
+          {
+            agent: "codex",
+            agent_session: { value: "session-1" },
+            cwd: "/repo",
+            pane_id: "w32:p1",
+            workspace_id: "w32",
+            tab_id: "w32:t1",
+          },
+        ],
+      },
+    });
+
+    expect(panes).toEqual([
+      {
+        agent: "codex",
+        agentSessionId: "session-1",
+        cwd: "/repo",
+        paneId: "w32:p1",
+        workspaceId: "w32",
+        tabId: "w32:t1",
+      },
+    ]);
+  });
+
+  it("matches by foreground PID before falling back to ambiguous cwd and type", () => {
+    const pane = findMatchingHerdrPane(
+      {
+        type: "codex",
+        projectPath: "/repo",
+        sessionId: "pid-64904",
+        pid: 64904,
+      },
+      [
+        { agent: "codex", cwd: "/repo", paneId: "w31:p1", foregroundPids: [44290] },
+        { agent: "codex", cwd: "/repo", paneId: "w32:p1", foregroundPids: [64904] },
+      ],
+    );
+
+    expect(pane?.paneId).toBe("w32:p1");
+  });
+
+  it("prefers a foreground PID match over a shell PID match", () => {
+    const pane = findMatchingHerdrPane(
+      {
+        type: "codex",
+        projectPath: "/repo",
+        sessionId: "pid-64904",
+        pid: 64904,
+      },
+      [
+        { agent: "codex", cwd: "/repo", paneId: "w31:p1", shellPid: 64904 },
+        { agent: "codex", cwd: "/repo", paneId: "w32:p1", foregroundPids: [64904] },
+      ],
+    );
+
+    expect(pane?.paneId).toBe("w32:p1");
+  });
+
+  it("enriches pane list output with foreground process IDs", async () => {
+    const runner = vi
+      .fn<HerdrCommandRunner>()
+      .mockResolvedValueOnce(
+        jsonResponse({
+          result: {
+            panes: [
+              { agent: "codex", cwd: "/repo", pane_id: "w31:p1" },
+              { agent: "codex", cwd: "/repo", pane_id: "w32:p1" },
+            ],
+          },
+        }),
+      )
+      .mockResolvedValueOnce(
+        jsonResponse({
+          result: {
+            process_info: {
+              pane_id: "w31:p1",
+              shell_pid: 111,
+              foreground_processes: [{ pid: 44290 }],
+            },
+          },
+        }),
+      )
+      .mockResolvedValueOnce(
+        jsonResponse({
+          result: {
+            process_info: {
+              pane_id: "w32:p1",
+              shell_pid: 222,
+              foreground_processes: [{ pid: 64904 }],
+            },
+          },
+        }),
+      );
+
+    const panes = await fetchHerdrAgentPanes(runner);
+
+    expect(runner).toHaveBeenNthCalledWith(1, "herdr", ["pane", "list"]);
+    expect(runner).toHaveBeenNthCalledWith(2, "herdr", [
+      "pane",
+      "process-info",
+      "--pane",
+      "w31:p1",
+    ]);
+    expect(runner).toHaveBeenNthCalledWith(3, "herdr", [
+      "pane",
+      "process-info",
+      "--pane",
+      "w32:p1",
+    ]);
+    expect(panes).toMatchObject([
+      { paneId: "w31:p1", foregroundPids: [44290], shellPid: 111 },
+      { paneId: "w32:p1", foregroundPids: [64904], shellPid: 222 },
+    ]);
+  });
+});

package/src/__tests__/runtime/HerdrAgentRuntime.test.ts

@@ -186,11 +186,30 @@ describe("HerdrAgentRuntime", () => {
       agentResponse(),
       processInfoResponse({ shellPid: 12000 }),
     ]);
-    const runtime = new HerdrAgentRuntime({ runner, env: {} });
+    const runtime = new HerdrAgentRuntime({ runner, env: {}, processInfoPollMs: 0 });
 
     await expect(runtime.startAgent(startInput)).resolves.toMatchObject({ pid: 12000 });
   });
 
+  it("waits for a foreground process pid before falling back to the pane shell pid", async () => {
+    const runner = createRunner([
+      workspaceResponse(),
+      agentResponse(),
+      processInfoResponse({ shellPid: 12000 }),
+      processInfoResponse({ shellPid: 12000, pid: 12345, processName: "node" }),
+    ]);
+    const runtime = new HerdrAgentRuntime({
+      runner,
+      env: {},
+      processInfoPollMs: 100,
+      processInfoPollIntervalMs: 0,
+    });
+
+    await expect(runtime.startAgent(startInput)).resolves.toMatchObject({ pid: 12345 });
+    expect(runner).toHaveBeenNthCalledWith(3, "herdr", ["pane", "process-info", "--pane", "w1:p1"]);
+    expect(runner).toHaveBeenNthCalledWith(4, "herdr", ["pane", "process-info", "--pane", "w1:p1"]);
+  });
+
   it("passes only explicit extra agent args after the Herdr start separator", async () => {
     const runner = createRunner([
       workspaceResponse(),

package/src/__tests__/utils/AgentRegistry.test.ts

@@ -92,24 +92,34 @@ describe("AgentRegistry", () => {
       });
     });
 
-    it("lets a Herdr managed start replace an existing same-pid name", () => {
+    it("preserves existing identity and routing fields for same-pid refreshes", () => {
       const runtimeRef = { session: "default", paneId: "w1:p2", agentName: "requested-name" };
 
-      registry.register(makeEntry({ name: "old-name", pid: process.pid }));
+      registry.register(
+        makeEntry({
+          name: "old-name",
+          pid: process.pid,
+          runtime: "tmux",
+          runtimeRef: { session: "old-name" },
+          cwd: "/original",
+        }),
+      );
       registry.register(
         makeEntry({
           name: "requested-name",
           pid: process.pid,
           runtime: "herdr",
           runtimeRef,
+          cwd: "/incoming",
         }),
       );
 
-      expect(registry.lookup("old-name")).toBeNull();
-      expect(registry.lookup("requested-name")).toMatchObject({
+      expect(registry.lookup("requested-name")).toBeNull();
+      expect(registry.lookup("old-name")).toMatchObject({
         pid: process.pid,
-        runtime: "herdr",
-        runtimeRef,
+        runtime: "tmux",
+        runtimeRef: { session: "old-name" },
+        cwd: "/original",
       });
     });
 
@@ -127,11 +137,11 @@ describe("AgentRegistry", () => {
       expect(registry.lookup("a")?.runtimeRef).toBeNull();
     });
 
-    it("lets a managed start entry replace a generated fallback for the same pid", () => {
+    it("preserves an existing generated fallback for the same pid", () => {
       registry.register(makeEntry({ name: `ai-devkit-${process.pid}`, runtimeRef: null }));
       registry.register(makeEntry({ name: "custom-name", runtimeRef: { session: "custom-name" } }));
-      expect(registry.lookup("custom-name")?.runtimeRef).toEqual({ session: "custom-name" });
-      expect(registry.lookup(`ai-devkit-${process.pid}`)).toBeNull();
+      expect(registry.lookup("custom-name")).toBeNull();
+      expect(registry.lookup(`ai-devkit-${process.pid}`)?.runtimeRef).toBeNull();
       expect(registry.list()).toHaveLength(1);
     });
 
@@ -186,7 +196,7 @@ describe("AgentRegistry", () => {
       registry.register(makeEntry({ name: `ai-devkit-${process.pid}`, runtimeRef: null }));
 
       expect(registry.list()).toHaveLength(1);
-      expect(registry.lookup("custom-name")?.pid).toBe(process.pid);
+      expect(registry.lookup(`ai-devkit-${process.pid}`)?.pid).toBe(process.pid);
     });
 
     it("cleans up a cross-type row when its pid has been reused", () => {

package/src/adapters/OpenCodeAdapter.ts

@@ -65,17 +65,21 @@ export class OpenCodeAdapter implements AgentAdapter {
   private static readonly IDLE_THRESHOLD_MINUTES = 5;
 
   private readonly dbPath: string;
+  private readonly cleanup = (): void => this.close();
   private db: Database.Database | null = null;
 
   constructor() {
     this.dbPath = OpenCodeAdapter.resolveDbPath();
-    const cleanup = (): void => this.close();
-    process.once("exit", cleanup);
-    process.once("SIGINT", cleanup);
-    process.once("SIGTERM", cleanup);
+    process.once("exit", this.cleanup);
+    process.once("SIGINT", this.cleanup);
+    process.once("SIGTERM", this.cleanup);
   }
 
   close(): void {
+    process.off("exit", this.cleanup);
+    process.off("SIGINT", this.cleanup);
+    process.off("SIGTERM", this.cleanup);
+
     if (this.db) {
       try {
         this.db.close();

package/src/adapters/index.ts

@@ -1,7 +1,7 @@
 export { ClaudeCodeAdapter } from "../providers/claude/ClaudeCodeAdapter.js";
 export { CodexAdapter } from "../providers/codex/CodexAdapter.js";
-export { CopilotAdapter } from "./CopilotAdapter.js";
-export { GeminiCliAdapter } from "./GeminiCliAdapter.js";
+export { CopilotAdapter } from "../providers/copilot/CopilotAdapter.js";
+export { GeminiCliAdapter } from "../providers/gemini/GeminiCliAdapter.js";
 export { GrokCliAdapter } from "./GrokCliAdapter.js";
 export { OpenCodeAdapter } from "./OpenCodeAdapter.js";
 export { PiAdapter } from "../providers/pi/PiAdapter.js";

package/src/index.ts

@@ -22,8 +22,8 @@ export type {
 
 export { ClaudeCodeAdapter } from "./providers/claude/ClaudeCodeAdapter.js";
 export { CodexAdapter } from "./providers/codex/CodexAdapter.js";
-export { CopilotAdapter } from "./adapters/CopilotAdapter.js";
-export { GeminiCliAdapter } from "./adapters/GeminiCliAdapter.js";
+export { CopilotAdapter } from "./providers/copilot/CopilotAdapter.js";
+export { GeminiCliAdapter } from "./providers/gemini/GeminiCliAdapter.js";
 export { GrokCliAdapter } from "./adapters/GrokCliAdapter.js";
 export { OpenCodeAdapter } from "./adapters/OpenCodeAdapter.js";
 export { PiAdapter } from "./providers/pi/PiAdapter.js";
@@ -43,7 +43,14 @@ export { TerminalFocusManager, TerminalType } from "./terminal/TerminalFocusMana
 export type { TerminalLocation } from "./terminal/TerminalFocusManager.js";
 export { TtyWriter } from "./terminal/TtyWriter.js";
 
-export type { ListAgentsOptions } from "./AgentManager.js";
+export type { AgentManagerOptions, ListAgentsOptions } from "./AgentManager.js";
+export {
+  extractHerdrAgentPanes,
+  fetchHerdrAgentPanes,
+  findMatchingHerdrPane,
+  herdrPaneToRuntimeRef,
+} from "./runtime/herdr/HerdrAgentDiscovery.js";
+export type { HerdrAgentPane } from "./runtime/herdr/HerdrAgentDiscovery.js";
 
 export {
   AgentRegistry,

package/src/providers/copilot/CopilotAdapter.ts

@@ -0,0 +1,145 @@
+/**
+ * Copilot Adapter
+ *
+ * Detects running GitHub Copilot CLI agents by:
+ * 1. Filtering Copilot processes from a shared asynchronous process snapshot
+ * 2. Using snapshot CWD and start-time enrichment
+ * 3. Mapping active ~/.copilot/session-state/{sessionId}/inuse.{pid}.lock files to processes
+ * 4. Reading events.jsonl as the primary session/conversation source
+ * 5. Reading workspace.yaml as a flat fallback metadata source
+ */
+
+import * as path from "path";
+import type {
+  AgentAdapter,
+  AgentInfo,
+  ConversationMessage,
+  ListSessionsOptions,
+  ProcessInfo,
+  SessionSummary,
+  AgentDetectionContext,
+} from "../../adapters/AgentAdapter.js";
+import {
+  captureProcessSnapshot,
+  executableBasename,
+  filterByProcessNames,
+  findWrapperProcess,
+  findWrapperProcessPids,
+} from "../../utils/process.js";
+import { AgentRegistry, type RegistryEntry } from "../../utils/AgentRegistry.js";
+import { CopilotAgentMapper } from "./CopilotAgentMapper.js";
+import { CopilotSessionLocator } from "./CopilotSessionLocator.js";
+import { CopilotSessionParser } from "./CopilotSessionParser.js";
+
+export interface CopilotAdapterOptions {
+  sessionStateDir?: string;
+}
+
+export class CopilotAdapter implements AgentAdapter {
+  readonly type = "copilot" as const;
+  readonly processNames = ["copilot"] as const;
+
+  private readonly registry: AgentRegistry;
+  private readonly parser: CopilotSessionParser;
+  private readonly mapper: CopilotAgentMapper;
+  private readonly locator: CopilotSessionLocator;
+
+  constructor(
+    registry: AgentRegistry = AgentRegistry.default(),
+    options: CopilotAdapterOptions = {},
+  ) {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    this.registry = registry;
+    this.parser = new CopilotSessionParser();
+    this.mapper = new CopilotAgentMapper(this.parser);
+    this.locator = new CopilotSessionLocator({
+      sessionStateDir: options.sessionStateDir ?? path.join(homeDir, ".copilot", "session-state"),
+    });
+  }
+
+  canHandle(processInfo: ProcessInfo): boolean {
+    return this.isCopilotExecutable(processInfo.command);
+  }
+
+  async detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {
+    const snapshot = context?.processes ?? (await captureProcessSnapshot(this.processNames));
+    const relevant = filterByProcessNames(snapshot, this.processNames);
+    const processes = relevant.filter((process) => this.canHandle(process));
+    if (processes.length === 0) return [];
+
+    const processByPid = new Map(processes.map((proc) => [proc.pid, proc]));
+    const registryEntriesByPid = new Map(this.registry.list().map((entry) => [entry.pid, entry]));
+    const matchedPids = new Set<number>();
+    const matchedProcesses: ProcessInfo[] = [];
+    const agents: AgentInfo[] = [];
+
+    for (const lock of this.locator.discoverActiveLocks()) {
+      const proc = processByPid.get(lock.pid);
+      if (!proc) continue;
+
+      const session = this.parser.readSessionDir(lock.sessionDir, lock.sessionId);
+      if (!session) continue;
+
+      const agent = this.mapper.mapSessionToAgent(session, proc);
+      this.applyWrapperRegistryName(agent, proc, processes, registryEntriesByPid);
+      agents.push(agent);
+      matchedPids.add(proc.pid);
+      matchedProcesses.push(proc);
+    }
+
+    const wrapperPids = findWrapperProcessPids(processes, matchedProcesses);
+    for (const proc of processes) {
+      if (!matchedPids.has(proc.pid) && !wrapperPids.has(proc.pid)) {
+        const agent = this.mapper.mapProcessOnlyAgent(proc);
+        this.applyWrapperRegistryName(agent, proc, processes, registryEntriesByPid);
+        agents.push(agent);
+      }
+    }
+
+    return agents;
+  }
+
+  getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {
+    return this.parser.getConversation(sessionFilePath, options);
+  }
+
+  async listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]> {
+    const summaries: SessionSummary[] = [];
+
+    for (const { sessionDir, sessionId } of this.locator.listSessionDirs()) {
+      const session = this.parser.readSessionDir(sessionDir, sessionId);
+      if (!session) continue;
+      if (opts?.cwd !== undefined && session.projectPath !== opts.cwd) continue;
+
+      summaries.push({
+        type: this.type,
+        sessionId: session.sessionId,
+        cwd: session.projectPath,
+        firstUserMessage: session.firstUserMessage,
+        lastActive: session.lastActive,
+        startedAt: session.sessionStart,
+        sessionFilePath: session.eventsFilePath,
+      });
+    }
+
+    return summaries;
+  }
+
+  private applyWrapperRegistryName(
+    agent: AgentInfo,
+    processInfo: ProcessInfo,
+    processes: ProcessInfo[],
+    registryEntriesByPid: Map<number, RegistryEntry>,
+  ): void {
+    const wrapper = findWrapperProcess(processes, processInfo);
+    const wrapperEntry = wrapper ? registryEntriesByPid.get(wrapper.pid) : undefined;
+    if (wrapperEntry?.type === this.type) {
+      agent.name = wrapperEntry.name;
+    }
+  }
+
+  private isCopilotExecutable(command: string): boolean {
+    const base = executableBasename(command);
+    return base === "copilot" || base === "copilot.exe";
+  }
+}

package/src/providers/copilot/CopilotAgentMapper.ts

@@ -0,0 +1,36 @@
+import type { AgentInfo, ProcessInfo } from "../../adapters/AgentAdapter.js";
+import { AgentStatus } from "../../adapters/AgentAdapter.js";
+import { generateAgentName } from "../../utils/matching.js";
+import { CopilotSessionParser, type CopilotSession } from "./CopilotSessionParser.js";
+
+export class CopilotAgentMapper {
+  constructor(private readonly parser: CopilotSessionParser = new CopilotSessionParser()) {}
+
+  mapSessionToAgent(session: CopilotSession, processInfo: ProcessInfo): AgentInfo {
+    const projectPath = session.projectPath || processInfo.cwd || "";
+    return {
+      name: generateAgentName(projectPath, processInfo.pid),
+      type: "copilot",
+      status: this.parser.determineStatus(session),
+      summary: session.summary || "Copilot session active",
+      pid: processInfo.pid,
+      projectPath,
+      sessionId: session.sessionId,
+      lastActive: session.lastActive,
+      sessionFilePath: session.eventsFilePath,
+    };
+  }
+
+  mapProcessOnlyAgent(processInfo: ProcessInfo): AgentInfo {
+    return {
+      name: generateAgentName(processInfo.cwd || "", processInfo.pid),
+      type: "copilot",
+      status: AgentStatus.RUNNING,
+      summary: "Copilot process running",
+      pid: processInfo.pid,
+      projectPath: processInfo.cwd || "",
+      sessionId: `pid-${processInfo.pid}`,
+      lastActive: new Date(),
+    };
+  }
+}

package/src/providers/copilot/CopilotSessionLocator.ts

@@ -0,0 +1,57 @@
+import * as path from "path";
+import { isDirectory, safeReaddir } from "../../utils/session.js";
+
+export interface CopilotLock {
+  sessionDir: string;
+  sessionId: string;
+  pid: number;
+}
+
+export interface CopilotSessionDir {
+  sessionDir: string;
+  sessionId: string;
+}
+
+export interface CopilotSessionLocatorOptions {
+  sessionStateDir?: string;
+}
+
+export class CopilotSessionLocator {
+  private readonly sessionStateDir: string;
+
+  constructor(options: CopilotSessionLocatorOptions = {}) {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    this.sessionStateDir =
+      options.sessionStateDir ?? path.join(homeDir, ".copilot", "session-state");
+  }
+
+  listSessionDirs(): CopilotSessionDir[] {
+    if (!isDirectory(this.sessionStateDir)) return [];
+
+    const sessionDirs: CopilotSessionDir[] = [];
+    for (const sessionId of safeReaddir(this.sessionStateDir)) {
+      const sessionDir = path.join(this.sessionStateDir, sessionId);
+      if (!isDirectory(sessionDir)) continue;
+
+      sessionDirs.push({ sessionDir, sessionId });
+    }
+
+    return sessionDirs;
+  }
+
+  discoverActiveLocks(): CopilotLock[] {
+    const locks: CopilotLock[] = [];
+    for (const { sessionDir, sessionId } of this.listSessionDirs()) {
+      for (const entry of safeReaddir(sessionDir)) {
+        const match = entry.match(/^inuse\.(\d+)\.lock$/);
+        if (!match) continue;
+
+        const pid = Number.parseInt(match[1], 10);
+        if (!Number.isFinite(pid)) continue;
+        locks.push({ sessionDir, sessionId, pid });
+      }
+    }
+
+    return locks;
+  }
+}