@ai-devkit/agent-manager 0.33.0 → 0.34.0

package/src/index.ts

@@ -1,6 +1,11 @@
 export { AgentManager, AgentNotRunningError } from "./AgentManager.js";
-export { getCodexCapacityReport } from "./capacity/index.js";
-export type { CapacityProbeOptions, CapacityReport, CapacityWindow } from "./capacity/index.js";
+export { getCodexCapacityReport, getZaiCapacityReport } from "./capacity/index.js";
+export type {
+  CapacityProbeOptions,
+  CapacityReport,
+  CapacityWindow,
+  ZaiCapacityOptions,
+} from "./capacity/index.js";
 export {
   getAgentReadinessReport,
   getAgentReadinessReports,
@@ -22,10 +27,10 @@ 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 { OpenCodeAdapter } from "./providers/opencode/OpenCodeAdapter.js";
 export { PiAdapter } from "./providers/pi/PiAdapter.js";
 export { AgentStatus } from "./adapters/AgentAdapter.js";
 export type {
@@ -43,7 +48,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;
+  }
+}

package/src/providers/copilot/CopilotSessionParser.ts

@@ -0,0 +1,289 @@
+import * as path from "path";
+import type { ConversationMessage } from "../../adapters/AgentAdapter.js";
+import { AgentStatus } from "../../adapters/AgentAdapter.js";
+import { safeReadFile, safeStat } from "../../utils/session.js";
+
+interface CopilotEventEntry {
+  type?: string;
+  data?: {
+    sessionId?: string;
+    startTime?: string;
+    context?: {
+      cwd?: string;
+      gitRoot?: string;
+      branch?: string;
+    };
+    content?: string;
+    transformedContent?: string;
+    message?: string;
+    text?: string;
+    result?: {
+      content?: string;
+      detailedContent?: string;
+    };
+    output?: string;
+  };
+  timestamp?: string;
+}
+
+interface CopilotWorkspace {
+  id?: string;
+  cwd?: string;
+  name?: string;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+export interface CopilotSession {
+  sessionId: string;
+  projectPath: string;
+  summary: string;
+  sessionStart: Date;
+  lastActive: Date;
+  lastEventType?: string;
+  firstUserMessage: string;
+  eventsFilePath: string;
+}
+
+interface CopilotEventSummary {
+  sessionId: string;
+  projectPath: string;
+  sessionStart: Date;
+  lastActive: Date;
+  firstUserMessage: string;
+  lastText: string;
+  lastEventType?: string;
+}
+
+const IDLE_THRESHOLD_MINUTES = 5;
+const VERBOSE_SYSTEM_EVENTS = new Set([
+  "system.message",
+  "session.info",
+  "session.warning",
+  "tool.execution_start",
+  "tool.execution_complete",
+  "function",
+  "abort",
+]);
+const WAITING_EVENTS = new Set([
+  "assistant.message",
+  "assistant.turn_end",
+  "session.shutdown",
+  "abort",
+]);
+
+export class CopilotSessionParser {
+  readSessionDir(sessionDir: string, fallbackSessionId: string): CopilotSession | null {
+    const eventsFilePath = path.join(sessionDir, "events.jsonl");
+    const workspace = this.readWorkspaceMetadata(path.join(sessionDir, "workspace.yaml"));
+    const entries = this.readEventEntries(eventsFilePath);
+    if (entries.length === 0 && !this.hasWorkspaceMetadata(workspace)) {
+      return null;
+    }
+
+    const fileStat = safeStat(eventsFilePath);
+    const sessionStart = workspace.createdAt || fileStat?.birthtime || new Date();
+    const eventSummary = this.buildSessionFromEntries(entries, {
+      sessionId: workspace.id || fallbackSessionId,
+      projectPath: workspace.cwd || "",
+      sessionStart,
+      lastActive: workspace.updatedAt || fileStat?.mtime || sessionStart,
+      firstUserMessage: "",
+      lastText: "",
+    });
+
+    const summary =
+      eventSummary.firstUserMessage ||
+      eventSummary.lastText ||
+      workspace.name ||
+      "Copilot session active";
+
+    return {
+      sessionId: eventSummary.sessionId,
+      projectPath: eventSummary.projectPath,
+      summary: this.truncate(summary, 120),
+      sessionStart: eventSummary.sessionStart,
+      lastActive: eventSummary.lastActive,
+      lastEventType: eventSummary.lastEventType,
+      firstUserMessage: eventSummary.firstUserMessage,
+      eventsFilePath,
+    };
+  }
+
+  getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {
+    const verbose = options?.verbose ?? false;
+    const content = safeReadFile(sessionFilePath);
+    if (content === undefined) return [];
+
+    const messages: ConversationMessage[] = [];
+
+    for (const entry of this.parseEventLines(content)) {
+      const role = this.roleForEvent(entry.type, verbose);
+      if (!role) continue;
+
+      const text = this.extractEventText(entry, verbose);
+      if (!text) continue;
+
+      messages.push({
+        role,
+        content: text,
+        timestamp: entry.timestamp,
+      });
+    }
+
+    return messages;
+  }
+
+  determineStatus(session: CopilotSession): AgentStatus {
+    const diffMs = Date.now() - session.lastActive.getTime();
+    const diffMinutes = diffMs / 60000;
+    if (diffMinutes > IDLE_THRESHOLD_MINUTES) {
+      return AgentStatus.IDLE;
+    }
+
+    if (session.lastEventType !== undefined && WAITING_EVENTS.has(session.lastEventType)) {
+      return AgentStatus.WAITING;
+    }
+
+    return AgentStatus.RUNNING;
+  }
+
+  private readEventEntries(eventsFilePath: string): CopilotEventEntry[] {
+    const content = safeReadFile(eventsFilePath);
+    return content === undefined ? [] : this.parseEventLines(content);
+  }
+
+  private buildSessionFromEntries(
+    entries: CopilotEventEntry[],
+    initial: CopilotEventSummary,
+  ): CopilotEventSummary {
+    const summary = { ...initial };
+    for (const entry of entries) {
+      const timestamp = this.parseTimestamp(entry.timestamp);
+      if (timestamp) {
+        summary.lastActive = timestamp;
+      }
+      if (entry.type) {
+        summary.lastEventType = entry.type;
+      }
+
+      if (entry.type === "session.start") {
+        summary.sessionId = entry.data?.sessionId || summary.sessionId;
+        summary.projectPath = entry.data?.context?.cwd || summary.projectPath;
+        summary.sessionStart =
+          this.parseTimestamp(entry.data?.startTime) || timestamp || summary.sessionStart;
+        continue;
+      }
+
+      const text = this.extractEventText(entry, false);
+      if (!text) continue;
+
+      if (!summary.firstUserMessage && entry.type === "user.message") {
+        summary.firstUserMessage = text;
+      }
+
+      if (entry.type === "user.message" || entry.type === "assistant.message") {
+        summary.lastText = text;
+      }
+    }
+
+    return summary;
+  }
+
+  private hasWorkspaceMetadata(workspace: CopilotWorkspace): boolean {
+    return Boolean(
+      workspace.id || workspace.cwd || workspace.name || workspace.createdAt || workspace.updatedAt,
+    );
+  }
+
+  private readWorkspaceMetadata(filePath: string): CopilotWorkspace {
+    const content = safeReadFile(filePath);
+    if (content === undefined) return {};
+
+    const values = new Map<string, string>();
+    for (const rawLine of content.split("\n")) {
+      const line = rawLine.trim();
+      if (!line || line.startsWith("#")) continue;
+
+      const idx = line.indexOf(":");
+      if (idx === -1) continue;
+
+      const key = line.slice(0, idx).trim();
+      const value = this.stripYamlScalar(line.slice(idx + 1).trim());
+      values.set(key, value);
+    }
+
+    return {
+      id: values.get("id"),
+      cwd: values.get("cwd"),
+      name: values.get("name"),
+      createdAt: this.parseTimestamp(values.get("created_at")) || undefined,
+      updatedAt: this.parseTimestamp(values.get("updated_at")) || undefined,
+    };
+  }
+
+  private stripYamlScalar(value: string): string {
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      return value.slice(1, -1);
+    }
+    return value;
+  }
+
+  private parseEventLines(content: string): CopilotEventEntry[] {
+    const entries: CopilotEventEntry[] = [];
+    for (const line of content.trim().split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+
+      try {
+        entries.push(JSON.parse(trimmed) as CopilotEventEntry);
+      } catch {
+        continue;
+      }
+    }
+    return entries;
+  }
+
+  private roleForEvent(
+    type: string | undefined,
+    verbose: boolean,
+  ): ConversationMessage["role"] | null {
+    if (type === "user.message") return "user";
+    if (type === "assistant.message") return "assistant";
+    if (verbose && type !== undefined && VERBOSE_SYSTEM_EVENTS.has(type)) {
+      return "system";
+    }
+    return null;
+  }
+
+  private extractEventText(entry: CopilotEventEntry, verbose: boolean): string {
+    const data = entry.data;
+    if (!data) return "";
+
+    const raw =
+      data.content ||
+      data.message ||
+      data.text ||
+      data.result?.content ||
+      data.result?.detailedContent ||
+      (verbose ? data.output : "") ||
+      "";
+
+    if (typeof raw !== "string") return "";
+    return raw.trim();
+  }
+
+  private parseTimestamp(value?: string): Date | null {
+    if (!value) return null;
+    const timestamp = new Date(value);
+    return Number.isNaN(timestamp.getTime()) ? null : timestamp;
+  }
+
+  private truncate(value: string, maxLength: number): string {
+    if (value.length <= maxLength) return value;
+    return `${value.slice(0, maxLength - 3)}...`;
+  }
+}

package/src/providers/gemini/GeminiAgentMapper.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 { GeminiSessionParser, type GeminiSession } from "./GeminiSessionParser.js";
+
+export class GeminiAgentMapper {
+  constructor(private readonly parser: GeminiSessionParser = new GeminiSessionParser()) {}
+
+  mapSessionToAgent(session: GeminiSession, processInfo: ProcessInfo, filePath: string): AgentInfo {
+    const projectPath = session.projectPath || processInfo.cwd || "";
+    return {
+      name: generateAgentName(projectPath, processInfo.pid),
+      type: "gemini_cli",
+      status: this.parser.determineStatus(session),
+      summary: session.summary || "Gemini CLI session active",
+      pid: processInfo.pid,
+      projectPath,
+      sessionId: session.sessionId,
+      lastActive: session.lastActive,
+      sessionFilePath: filePath,
+    };
+  }
+
+  mapProcessOnlyAgent(processInfo: ProcessInfo): AgentInfo {
+    return {
+      name: generateAgentName(processInfo.cwd || "", processInfo.pid),
+      type: "gemini_cli",
+      status: AgentStatus.RUNNING,
+      summary: "Gemini CLI process running",
+      pid: processInfo.pid,
+      projectPath: processInfo.cwd || "",
+      sessionId: `pid-${processInfo.pid}`,
+      lastActive: new Date(),
+    };
+  }
+}