@ai-devkit/agent-manager 0.33.0 → 0.34.0

package/src/providers/gemini/GeminiCliAdapter.ts

@@ -0,0 +1,266 @@
+/**
+ * Gemini CLI Adapter
+ *
+ * Detects running Gemini CLI agents by:
+ * 1. Filtering Gemini Node processes from a shared asynchronous process snapshot
+ * 2. Using snapshot CWD and start-time enrichment
+ * 3. Discovering session files from ~/.gemini/tmp/<shortId>/chats/session-*.json
+ * 4. Matching sessions to processes via shared matchProcessesToSessions()
+ *    using sha256(cwd) === session.projectHash as the resolvedCwd source
+ * 5. Extracting summary from the most recent user message in the session JSON
+ */
+
+import type {
+  AgentAdapter,
+  AgentInfo,
+  ProcessInfo,
+  ConversationMessage,
+  SessionSummary,
+  ListSessionsOptions,
+  AgentDetectionContext,
+} from "../../adapters/AgentAdapter.js";
+import {
+  captureProcessSnapshot,
+  executableBasename,
+  filterByProcessNames,
+  findWrapperProcess,
+  findWrapperProcessPids,
+} from "../../utils/process.js";
+import { matchProcessesToSessions } from "../../utils/matching.js";
+import { AgentRegistry, type RegistryEntry } from "../../utils/AgentRegistry.js";
+import { GeminiAgentMapper } from "./GeminiAgentMapper.js";
+import { GeminiSessionLocator, type GeminiSessionDiscovery } from "./GeminiSessionLocator.js";
+import { GeminiSessionParser } from "./GeminiSessionParser.js";
+
+export interface GeminiCliAdapterOptions {
+  geminiTmpDir?: string;
+}
+
+export class GeminiCliAdapter implements AgentAdapter {
+  readonly type = "gemini_cli" as const;
+  readonly processNames = ["node"] as const;
+
+  private readonly registry: AgentRegistry;
+  private readonly parser: GeminiSessionParser;
+  private readonly mapper: GeminiAgentMapper;
+  private readonly locator: GeminiSessionLocator;
+
+  constructor(
+    registry: AgentRegistry = AgentRegistry.default(),
+    options: GeminiCliAdapterOptions = {},
+  ) {
+    this.registry = registry;
+    this.parser = new GeminiSessionParser();
+    this.mapper = new GeminiAgentMapper(this.parser);
+    this.locator = new GeminiSessionLocator(options);
+  }
+
+  canHandle(processInfo: ProcessInfo): boolean {
+    return this.isGeminiExecutable(processInfo.command);
+  }
+
+  /**
+   * Detect running Gemini CLI agents.
+   *
+   * Gemini CLI ships as a Node script (`bundle/gemini.js` with shebang
+   * `#!/usr/bin/env node`) — unlike Claude Code (native binary per
+   * platform) or Codex CLI (Node wrapper that execs a native Rust
+   * binary). The primary running process is therefore the Node runtime
+   * itself, and `ps aux` lists it as `node /path/to/gemini ...` with
+   * argv[0] = `node`. We scan the Node process pool via the shared
+   * snapshot and keep only those whose command line references the gemini
+   * executable or script via isGeminiExecutable().
+   */
+  async detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {
+    const processes = await this.getGeminiProcesses(context);
+    if (processes.length === 0) return [];
+
+    const wrapperPids = findWrapperProcessPids(processes);
+    const { cachedAgents, remaining } = this.tryRegistryCache(processes, wrapperPids);
+    if (remaining.length === 0) return this.deduplicateSessionAgents(cachedAgents);
+
+    const candidateProcesses = remaining.filter((proc) => !wrapperPids.has(proc.pid));
+    const registryEntriesByPid = new Map(this.registry.list().map((entry) => [entry.pid, entry]));
+    const discovery = this.locator.discoverSessions(candidateProcesses);
+
+    const agents =
+      discovery.sessions.length === 0
+        ? this.mapProcessOnlyAgents(candidateProcesses, processes, registryEntriesByPid)
+        : this.mapSessionDiscovery(discovery, candidateProcesses, processes, registryEntriesByPid);
+
+    return this.deduplicateSessionAgents([...cachedAgents, ...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 filePath of this.locator.discoverHistoricalSessionFiles()) {
+      const summary = this.parser.fileToSessionSummary(filePath);
+      if (!summary) continue;
+      if (opts?.cwd !== undefined && summary.cwd !== opts.cwd) continue;
+      summaries.push(summary);
+    }
+
+    return summaries;
+  }
+
+  private async getGeminiProcesses(context?: AgentDetectionContext): Promise<ProcessInfo[]> {
+    const snapshot = context?.processes ?? (await captureProcessSnapshot(this.processNames));
+    const relevant = filterByProcessNames(snapshot, this.processNames);
+    return relevant.filter((process) => this.canHandle(process));
+  }
+
+  private mapSessionDiscovery(
+    discovery: GeminiSessionDiscovery,
+    candidateProcesses: ProcessInfo[],
+    allProcesses: ProcessInfo[],
+    registryEntriesByPid: Map<number, RegistryEntry>,
+  ): AgentInfo[] {
+    const matches = matchProcessesToSessions(candidateProcesses, discovery.sessions);
+    const matchedPids = new Set(matches.map((m) => m.process.pid));
+    const matchedProcesses: ProcessInfo[] = [];
+    const agents: AgentInfo[] = [];
+
+    for (const match of matches) {
+      const cachedContent = discovery.contentCache.get(match.session.filePath);
+      const sessionData = this.parser.parseSession(cachedContent, match.session.filePath);
+      if (!sessionData) {
+        matchedPids.delete(match.process.pid);
+        continue;
+      }
+
+      const agent = this.mapper.mapSessionToAgent(
+        sessionData,
+        match.process,
+        match.session.filePath,
+      );
+      this.applyWrapperRegistryName(agent, match.process, allProcesses, registryEntriesByPid);
+      agents.push(agent);
+      matchedProcesses.push(match.process);
+    }
+
+    const matchedWrapperPids = findWrapperProcessPids(candidateProcesses, matchedProcesses);
+    const unmatchedProcesses = candidateProcesses.filter(
+      (process) => !matchedPids.has(process.pid) && !matchedWrapperPids.has(process.pid),
+    );
+
+    agents.push(
+      ...this.mapProcessOnlyAgents(unmatchedProcesses, allProcesses, registryEntriesByPid),
+    );
+    return agents;
+  }
+
+  private mapProcessOnlyAgents(
+    processes: ProcessInfo[],
+    allProcesses: ProcessInfo[],
+    registryEntriesByPid: Map<number, RegistryEntry>,
+  ): AgentInfo[] {
+    return processes.map((processInfo) => {
+      const agent = this.mapper.mapProcessOnlyAgent(processInfo);
+      this.applyWrapperRegistryName(agent, processInfo, allProcesses, registryEntriesByPid);
+      return agent;
+    });
+  }
+
+  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 deduplicateSessionAgents(agents: AgentInfo[]): AgentInfo[] {
+    const bySession = new Map<string, AgentInfo>();
+    const result: AgentInfo[] = [];
+
+    for (const agent of agents) {
+      const sessionKey = this.sessionDeduplicationKey(agent);
+      if (!sessionKey) {
+        result.push(agent);
+        continue;
+      }
+
+      const existing = bySession.get(sessionKey);
+      if (!existing) {
+        bySession.set(sessionKey, agent);
+        result.push(agent);
+        continue;
+      }
+
+      if (agent.pid > existing.pid) {
+        bySession.set(sessionKey, agent);
+        const index = result.indexOf(existing);
+        if (index >= 0) result[index] = agent;
+      }
+    }
+
+    return result;
+  }
+
+  private sessionDeduplicationKey(agent: AgentInfo): string | null {
+    if (agent.sessionFilePath) return `file:${agent.sessionFilePath}`;
+    if (agent.sessionId && !agent.sessionId.startsWith("pid-")) {
+      return `session:${agent.sessionId}`;
+    }
+    return null;
+  }
+
+  private tryRegistryCache(
+    processes: ProcessInfo[],
+    wrapperPids: Set<number>,
+  ): {
+    cachedAgents: AgentInfo[];
+    remaining: ProcessInfo[];
+  } {
+    const cachedAgents: AgentInfo[] = [];
+    const remaining: ProcessInfo[] = [];
+    const byPid = new Map(this.registry.list().map((e) => [e.pid, e]));
+
+    for (const proc of processes) {
+      const entry = byPid.get(proc.pid);
+      if (
+        wrapperPids.has(proc.pid) ||
+        !entry ||
+        entry.type !== this.type ||
+        !entry.sessionFilePath
+      ) {
+        remaining.push(proc);
+        continue;
+      }
+
+      const sessionData = this.parser.parseSession(undefined, entry.sessionFilePath);
+      if (!sessionData) {
+        remaining.push(proc);
+        continue;
+      }
+
+      cachedAgents.push(this.mapper.mapSessionToAgent(sessionData, proc, entry.sessionFilePath));
+    }
+
+    return { cachedAgents, remaining };
+  }
+
+  private isGeminiExecutable(command: string): boolean {
+    // Accept any token in the command line whose basename matches a
+    // known gemini entrypoint. This is intentionally broader than the
+    // other adapters' argv[0]-only check because the Node-script
+    // distribution puts the real gemini path in argv[1..], not argv[0].
+    for (const token of command.trim().split(/\s+/)) {
+      const base = executableBasename(token);
+      if (base === "gemini" || base === "gemini.exe" || base === "gemini.js") {
+        return true;
+      }
+    }
+    return false;
+  }
+}

package/src/providers/gemini/GeminiSessionLocator.ts

@@ -0,0 +1,183 @@
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+import type { ProcessInfo } from "../../adapters/AgentAdapter.js";
+import type { SessionFile } from "../../utils/session.js";
+import { isDirectory, safeReaddir } from "../../utils/session.js";
+
+export interface GeminiSessionDiscovery {
+  sessions: SessionFile[];
+  contentCache: Map<string, string>;
+}
+
+export interface GeminiSessionLocatorOptions {
+  geminiTmpDir?: string;
+}
+
+interface GeminiSessionMetadata {
+  sessionId?: string;
+  projectHash?: string;
+}
+
+const SESSION_FILE_PREFIX = "session-";
+const CHATS_DIR_NAME = "chats";
+
+export class GeminiSessionLocator {
+  private readonly geminiTmpDir: string;
+
+  constructor(options: GeminiSessionLocatorOptions = {}) {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    this.geminiTmpDir = options.geminiTmpDir ?? path.join(homeDir, ".gemini", "tmp");
+  }
+
+  /**
+   * Discover session files for the given processes.
+   *
+   * Gemini CLI writes sessions to ~/.gemini/tmp/<shortId>/chats/session-*.json
+   * where <shortId> is opaque (managed by a project registry). We scan every
+   * shortId directory and filter by matching session.projectHash against
+   * sha256(process.cwd) to bind each session to a candidate process CWD.
+   */
+  discoverSessions(processes: ProcessInfo[]): GeminiSessionDiscovery {
+    const empty = { sessions: [] as SessionFile[], contentCache: new Map<string, string>() };
+    if (!fs.existsSync(this.geminiTmpDir)) return empty;
+
+    const cwdHashMap = this.buildCwdHashMap(processes);
+    if (cwdHashMap.size === 0) return empty;
+
+    const contentCache = new Map<string, string>();
+    const sessions: SessionFile[] = [];
+
+    let shortIdEntries: string[];
+    try {
+      shortIdEntries = fs.readdirSync(this.geminiTmpDir);
+    } catch {
+      return empty;
+    }
+
+    for (const shortId of shortIdEntries) {
+      const chatsDir = path.join(this.geminiTmpDir, shortId, CHATS_DIR_NAME);
+      if (!isDirectory(chatsDir)) continue;
+
+      for (const fileName of safeReaddir(chatsDir)) {
+        if (!this.isSessionFile(fileName)) continue;
+
+        const session = this.readCandidateSession(chatsDir, fileName, cwdHashMap);
+        if (!session) continue;
+
+        contentCache.set(session.filePath, session.content);
+        sessions.push(session.sessionFile);
+      }
+    }
+
+    return { sessions, contentCache };
+  }
+
+  discoverHistoricalSessionFiles(): string[] {
+    if (!isDirectory(this.geminiTmpDir)) return [];
+
+    const files: string[] = [];
+    for (const shortId of safeReaddir(this.geminiTmpDir)) {
+      const chatsDir = path.join(this.geminiTmpDir, shortId, CHATS_DIR_NAME);
+      if (!isDirectory(chatsDir)) continue;
+
+      for (const fileName of safeReaddir(chatsDir)) {
+        if (this.isSessionFile(fileName)) {
+          files.push(path.join(chatsDir, fileName));
+        }
+      }
+    }
+
+    return files;
+  }
+
+  private readCandidateSession(
+    chatsDir: string,
+    fileName: string,
+    cwdHashMap: Map<string, string>,
+  ): { filePath: string; content: string; sessionFile: SessionFile } | null {
+    const filePath = path.join(chatsDir, fileName);
+
+    let content: string;
+    try {
+      content = fs.readFileSync(filePath, "utf-8");
+    } catch {
+      return null;
+    }
+
+    const parsed = this.parseSessionMetadata(content);
+    if (!parsed?.projectHash) return null;
+
+    const resolvedCwd = cwdHashMap.get(parsed.projectHash);
+    if (!resolvedCwd) return null;
+
+    let birthtimeMs = 0;
+    try {
+      birthtimeMs = fs.statSync(filePath).birthtimeMs;
+    } catch {
+      return null;
+    }
+
+    return {
+      filePath,
+      content,
+      sessionFile: {
+        sessionId: parsed.sessionId || fileName.replace(/\.json$/, ""),
+        filePath,
+        projectDir: chatsDir,
+        birthtimeMs,
+        resolvedCwd,
+      },
+    };
+  }
+
+  private buildCwdHashMap(processes: ProcessInfo[]): Map<string, string> {
+    const map = new Map<string, string>();
+    for (const proc of processes) {
+      if (!proc.cwd) continue;
+
+      // Gemini CLI resolves its project root by walking up from the
+      // startup directory looking for a `.git` boundary marker. A
+      // session's projectHash therefore tracks that ancestor rather
+      // than the process' actual CWD. Enumerate every ancestor as a
+      // candidate so subdirectory invocations still line up with the
+      // session the Gemini process wrote.
+      for (const candidate of this.candidateProjectRoots(proc.cwd)) {
+        const hash = this.hashProjectRoot(candidate);
+        if (!map.has(hash)) {
+          map.set(hash, proc.cwd);
+        }
+      }
+    }
+    return map;
+  }
+
+  private candidateProjectRoots(cwd: string): string[] {
+    const roots: string[] = [];
+    let current = path.resolve(cwd);
+    let parent = path.dirname(current);
+    while (parent !== current) {
+      roots.push(current);
+      current = parent;
+      parent = path.dirname(current);
+    }
+    roots.push(current);
+    return roots;
+  }
+
+  private hashProjectRoot(projectRoot: string): string {
+    return crypto.createHash("sha256").update(projectRoot).digest("hex");
+  }
+
+  private isSessionFile(fileName: string): boolean {
+    return fileName.startsWith(SESSION_FILE_PREFIX) && fileName.endsWith(".json");
+  }
+
+  private parseSessionMetadata(content: string): GeminiSessionMetadata | null {
+    try {
+      return JSON.parse(content) as GeminiSessionMetadata;
+    } catch {
+      return null;
+    }
+  }
+}