@ai-devkit/agent-manager 0.32.0 → 0.33.0

package/src/providers/codex/CodexAdapter.ts

@@ -0,0 +1,205 @@
+import * as fs from "fs";
+import * as path from "path";
+import type {
+  AgentAdapter,
+  AgentInfo,
+  ProcessInfo,
+  ConversationMessage,
+  SessionSummary,
+  ListSessionsOptions,
+  AgentDetectionContext,
+} from "../../adapters/AgentAdapter.js";
+import {
+  captureProcessSnapshot,
+  executableBasename,
+  filterByProcessNames,
+} from "../../utils/process.js";
+import { safeReadFile } from "../../utils/session.js";
+import { AgentRegistry } from "../../utils/AgentRegistry.js";
+import { CodexAgentMapper } from "./CodexAgentMapper.js";
+import { CodexSessionLocator, type CodexDirectMatch } from "./CodexSessionLocator.js";
+import { CodexSessionMapping } from "./CodexSessionMapping.js";
+import { CodexSessionParser } from "./CodexSessionParser.js";
+
+interface MappedAgentResult {
+  agents: AgentInfo[];
+  fallback: ProcessInfo[];
+}
+
+export class CodexAdapter implements AgentAdapter {
+  readonly type = "codex" as const;
+  readonly processNames = ["codex"] as const;
+
+  private readonly registry: AgentRegistry;
+  private readonly parser: CodexSessionParser;
+  private readonly mapper: CodexAgentMapper;
+  private readonly codexSessionsDir: string;
+  private readonly sessionMappingPath: string;
+
+  constructor(registry: AgentRegistry = AgentRegistry.default()) {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    this.registry = registry;
+    this.parser = new CodexSessionParser();
+    this.mapper = new CodexAgentMapper(this.parser);
+    this.codexSessionsDir = path.join(homeDir, ".codex", "sessions");
+    this.sessionMappingPath = path.join(homeDir, ".codex", "ai-devkit", "sessions.json");
+  }
+
+  canHandle(processInfo: ProcessInfo): boolean {
+    const base = executableBasename(processInfo.command);
+    return base === "codex" || base === "codex.exe";
+  }
+
+  async detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {
+    const processes = await this.getCodexProcesses(context);
+    if (processes.length === 0) return [];
+
+    const mappingResult = this.mapSessionMappingMatches(processes);
+    const cacheResult = this.mapRegistryCache(mappingResult.fallback);
+    const locatorResult = this.createLocator().matchRunningProcesses(cacheResult.fallback);
+
+    const directResult = this.mapDirectMatches(locatorResult.direct);
+    const legacyResult = this.mapLegacyMatches(
+      locatorResult.legacyMatches,
+      locatorResult.contentCache,
+    );
+    const unmatchedProcesses = this.findUnmatchedProcesses(locatorResult.fallback, [
+      ...directResult.agents,
+      ...legacyResult.agents,
+    ]);
+
+    return [
+      ...mappingResult.agents,
+      ...cacheResult.agents,
+      ...directResult.agents,
+      ...legacyResult.agents,
+      ...directResult.fallback.map((processInfo) => this.mapper.mapProcessOnlyAgent(processInfo)),
+      ...unmatchedProcesses.map((processInfo) => this.mapper.mapProcessOnlyAgent(processInfo)),
+    ];
+  }
+
+  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.createLocator().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 getCodexProcesses(context?: AgentDetectionContext): Promise<ProcessInfo[]> {
+    const snapshot = context?.processes ?? (await captureProcessSnapshot(this.processNames));
+    const relevant = filterByProcessNames(snapshot, this.processNames);
+    return relevant.filter((processInfo) => this.canHandle(processInfo));
+  }
+
+  private createLocator(): CodexSessionLocator {
+    return new CodexSessionLocator({ sessionsDir: this.codexSessionsDir }, this.parser);
+  }
+
+  private createSessionMapping(): CodexSessionMapping {
+    return new CodexSessionMapping({
+      mappingPath: this.sessionMappingPath,
+      sessionsDir: this.codexSessionsDir,
+    });
+  }
+
+  private mapSessionMappingMatches(processes: ProcessInfo[]): MappedAgentResult {
+    const { matches, fallback } = this.createSessionMapping().match(processes);
+    const agents: AgentInfo[] = [];
+
+    for (const match of matches) {
+      const session = this.parser.readSession(match.filePath);
+      if (session) {
+        agents.push(this.mapper.mapSessionToAgent(session, match.process, match.filePath));
+      } else {
+        fallback.push(match.process);
+      }
+    }
+
+    return { agents, fallback };
+  }
+
+  private mapRegistryCache(processes: ProcessInfo[]): MappedAgentResult {
+    const agents: AgentInfo[] = [];
+    const fallback: ProcessInfo[] = [];
+    const byPid = new Map(this.registry.list().map((entry) => [entry.pid, entry]));
+
+    for (const processInfo of processes) {
+      const entry = byPid.get(processInfo.pid);
+      if (
+        !entry ||
+        entry.type !== this.type ||
+        !entry.sessionFilePath ||
+        !fs.existsSync(entry.sessionFilePath)
+      ) {
+        fallback.push(processInfo);
+        continue;
+      }
+
+      const content = safeReadFile(entry.sessionFilePath);
+      const session = this.parser.readSession(entry.sessionFilePath, content);
+      if (!session) {
+        fallback.push(processInfo);
+        continue;
+      }
+
+      agents.push(this.mapper.mapSessionToAgent(session, processInfo, entry.sessionFilePath));
+    }
+
+    return { agents, fallback };
+  }
+
+  private mapDirectMatches(matches: CodexDirectMatch[]): MappedAgentResult {
+    const agents: AgentInfo[] = [];
+    const fallback: ProcessInfo[] = [];
+
+    for (const match of matches) {
+      const session = this.parser.readSession(match.sessionFile.filePath);
+      if (session) {
+        agents.push(
+          this.mapper.mapSessionToAgent(session, match.process, match.sessionFile.filePath),
+        );
+      } else {
+        fallback.push(match.process);
+      }
+    }
+
+    return { agents, fallback };
+  }
+
+  private mapLegacyMatches(
+    matches: Array<{ process: ProcessInfo; session: { filePath: string } }>,
+    contentCache: Map<string, string>,
+  ): MappedAgentResult {
+    const agents: AgentInfo[] = [];
+    const fallback: ProcessInfo[] = [];
+
+    for (const match of matches) {
+      const session = this.parser.readSession(
+        match.session.filePath,
+        contentCache.get(match.session.filePath),
+      );
+      if (session) {
+        agents.push(this.mapper.mapSessionToAgent(session, match.process, match.session.filePath));
+      } else {
+        fallback.push(match.process);
+      }
+    }
+
+    return { agents, fallback };
+  }
+
+  private findUnmatchedProcesses(processes: ProcessInfo[], agents: AgentInfo[]): ProcessInfo[] {
+    const matchedPids = new Set(agents.map((agent) => agent.pid));
+    return processes.filter((processInfo) => !matchedPids.has(processInfo.pid));
+  }
+}

package/src/providers/codex/CodexAgentMapper.ts

@@ -0,0 +1,35 @@
+import type { AgentInfo, ProcessInfo } from "../../adapters/AgentAdapter.js";
+import { AgentStatus } from "../../adapters/AgentAdapter.js";
+import { generateAgentName } from "../../utils/matching.js";
+import type { CodexSessionParser, CodexSession } from "./CodexSessionParser.js";
+
+export class CodexAgentMapper {
+  constructor(private readonly parser: CodexSessionParser) {}
+
+  mapSessionToAgent(session: CodexSession, processInfo: ProcessInfo, filePath: string): AgentInfo {
+    return {
+      name: generateAgentName(session.projectPath || processInfo.cwd || "", processInfo.pid),
+      type: "codex",
+      status: this.parser.determineStatus(session),
+      summary: session.summary || "Codex session active",
+      pid: processInfo.pid,
+      projectPath: session.projectPath || processInfo.cwd || "",
+      sessionId: session.sessionId,
+      lastActive: session.lastActive,
+      sessionFilePath: filePath,
+    };
+  }
+
+  mapProcessOnlyAgent(processInfo: ProcessInfo): AgentInfo {
+    return {
+      name: generateAgentName(processInfo.cwd || "", processInfo.pid),
+      type: "codex",
+      status: AgentStatus.RUNNING,
+      summary: "Codex process running",
+      pid: processInfo.pid,
+      projectPath: processInfo.cwd || "",
+      sessionId: `pid-${processInfo.pid}`,
+      lastActive: new Date(),
+    };
+  }
+}

package/src/providers/codex/CodexSessionLocator.ts

@@ -0,0 +1,279 @@
+import * as fs from "fs";
+import * as path from "path";
+import type { ProcessInfo } from "../../adapters/AgentAdapter.js";
+import { matchProcessesToSessions, type MatchResult } from "../../utils/matching.js";
+import {
+  batchGetSessionFileBirthtimes,
+  isDirectory,
+  safeReadFile,
+  safeReaddir,
+  safeStat,
+  type SessionFile,
+} from "../../utils/session.js";
+import { CodexSessionParser, type CodexEventEntry } from "./CodexSessionParser.js";
+
+export interface CodexDirectMatch {
+  process: ProcessInfo;
+  sessionFile: SessionFile;
+}
+
+export interface CodexProcessSessionMatches {
+  direct: CodexDirectMatch[];
+  legacyMatches: MatchResult[];
+  fallback: ProcessInfo[];
+  contentCache: Map<string, string>;
+}
+
+export interface CodexDiscoveredSessions {
+  sessions: SessionFile[];
+  contentCache: Map<string, string>;
+}
+
+export interface CodexSessionLocatorOptions {
+  sessionsDir?: string;
+}
+
+const PROCESS_START_DAY_WINDOW_DAYS = 1;
+
+export class CodexSessionLocator {
+  private readonly sessionsDir: string;
+
+  constructor(
+    options: CodexSessionLocatorOptions = {},
+    private readonly parser: CodexSessionParser = new CodexSessionParser(),
+  ) {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    this.sessionsDir = options.sessionsDir ?? path.join(homeDir, ".codex", "sessions");
+  }
+
+  matchRunningProcesses(processes: ProcessInfo[]): CodexProcessSessionMatches {
+    const { direct, fallback } = this.tryResumeMatching(processes);
+    const { sessions, contentCache } = this.discoverLiveSessions(fallback);
+    const legacyMatches =
+      fallback.length > 0 && sessions.length > 0
+        ? matchProcessesToSessions(fallback, sessions)
+        : [];
+
+    return { direct, legacyMatches, fallback, contentCache };
+  }
+
+  tryResumeMatching(processes: ProcessInfo[]): {
+    direct: CodexDirectMatch[];
+    fallback: ProcessInfo[];
+  } {
+    const direct: CodexDirectMatch[] = [];
+    const fallback: ProcessInfo[] = [];
+
+    for (const proc of processes) {
+      const sessionId = this.extractResumeSessionId(proc.command);
+      if (!sessionId) {
+        fallback.push(proc);
+        continue;
+      }
+
+      const sessionFile = this.findSessionFileById(sessionId);
+      if (!sessionFile) {
+        fallback.push(proc);
+        continue;
+      }
+
+      direct.push({ process: proc, sessionFile });
+    }
+
+    return { direct, fallback };
+  }
+
+  discoverLiveSessions(processes: ProcessInfo[]): CodexDiscoveredSessions {
+    const empty = { sessions: [], contentCache: new Map<string, string>() };
+    if (!fs.existsSync(this.sessionsDir)) return empty;
+
+    const dateDirs = this.getDateDirs(processes);
+    if (dateDirs.length === 0) return empty;
+
+    return this.discoverSessionFilesInDateDirs(dateDirs);
+  }
+
+  discoverSessionFilesInDateDirs(dateDirs: string[]): CodexDiscoveredSessions {
+    const files = batchGetSessionFileBirthtimes(dateDirs);
+    const contentCache = new Map<string, string>();
+
+    for (const file of files) {
+      try {
+        const content = fs.readFileSync(file.filePath, "utf-8");
+        contentCache.set(file.filePath, content);
+
+        const firstLine = content.split("\n")[0]?.trim();
+        if (firstLine) {
+          const parsed = JSON.parse(firstLine) as CodexEventEntry;
+          if (parsed.type === "session_meta") {
+            file.resolvedCwd = parsed.payload?.cwd || "";
+            const metaTimestampMs = this.parser.parseMetaTimestampMs(parsed.payload?.timestamp);
+            if (metaTimestampMs !== null) {
+              file.birthtimeMs = metaTimestampMs;
+            }
+          }
+        }
+      } catch {
+        // Skip unreadable files
+      }
+    }
+
+    return { sessions: files, contentCache };
+  }
+
+  discoverHistoricalSessionFiles(): string[] {
+    return this.collectAllSessionFiles();
+  }
+
+  findSessionFileById(sessionId: string): SessionFile | null {
+    for (const filePath of this.getCandidateSessionFiles(sessionId)) {
+      if (!path.basename(filePath).includes(sessionId)) continue;
+
+      const content = safeReadFile(filePath);
+      const firstLine = content?.split("\n")[0]?.trim();
+      if (!firstLine) continue;
+
+      try {
+        const parsed = JSON.parse(firstLine) as CodexEventEntry;
+        if (parsed.type !== "session_meta" || parsed.payload?.id !== sessionId) {
+          continue;
+        }
+
+        const stat = safeStat(filePath);
+        if (!stat) continue;
+        const metaTimestampMs = this.parser.parseMetaTimestampMs(parsed.payload?.timestamp);
+
+        return {
+          sessionId,
+          filePath,
+          projectDir: path.dirname(filePath),
+          birthtimeMs: metaTimestampMs ?? stat.birthtimeMs,
+          resolvedCwd: parsed.payload?.cwd || "",
+        };
+      } catch {
+        continue;
+      }
+    }
+
+    return null;
+  }
+
+  collectAllSessionFiles(): string[] {
+    const out: string[] = [];
+
+    for (const yearEntry of safeReaddir(this.sessionsDir)) {
+      const yearDir = path.join(this.sessionsDir, yearEntry);
+      if (!isDirectory(yearDir)) continue;
+
+      for (const monthEntry of safeReaddir(yearDir)) {
+        const monthDir = path.join(yearDir, monthEntry);
+        if (!isDirectory(monthDir)) continue;
+
+        for (const dayEntry of safeReaddir(monthDir)) {
+          const dayDir = path.join(monthDir, dayEntry);
+          if (!isDirectory(dayDir)) continue;
+
+          for (const fileEntry of safeReaddir(dayDir)) {
+            if (!fileEntry.endsWith(".jsonl")) continue;
+            out.push(path.join(dayDir, fileEntry));
+          }
+        }
+      }
+    }
+
+    return out;
+  }
+
+  private extractResumeSessionId(command: string): string | null {
+    const match = command.match(/(?:^|\s)resume\s+([0-9a-f-]{36})(?:\s|$)/i);
+    return match?.[1] ?? null;
+  }
+
+  private getCandidateSessionFiles(sessionId: string): string[] {
+    const sessionDate = this.tryParseUuidV7Date(sessionId);
+    if (!sessionDate) return this.collectAllSessionFiles();
+
+    return this.collectSessionFilesInDateDirs(
+      this.getDateDirsAroundDate(sessionDate, PROCESS_START_DAY_WINDOW_DAYS),
+    );
+  }
+
+  private getDateDirs(processes: ProcessInfo[]): string[] {
+    const dayKeys = new Set<string>();
+
+    for (const proc of processes) {
+      const startTime = proc.startTime || new Date();
+      for (
+        let offset = -PROCESS_START_DAY_WINDOW_DAYS;
+        offset <= PROCESS_START_DAY_WINDOW_DAYS;
+        offset++
+      ) {
+        const day = new Date(startTime.getTime());
+        day.setDate(day.getDate() + offset);
+        dayKeys.add(this.toSessionDayKey(day));
+      }
+    }
+
+    const dirs: string[] = [];
+    for (const dayKey of dayKeys) {
+      const dayDir = path.join(this.sessionsDir, dayKey);
+      try {
+        if (fs.statSync(dayDir).isDirectory()) {
+          dirs.push(dayDir);
+        }
+      } catch {
+        continue;
+      }
+    }
+
+    return dirs;
+  }
+
+  private getDateDirsAroundDate(date: Date, windowDays: number): string[] {
+    const dirs: string[] = [];
+
+    for (let offset = -windowDays; offset <= windowDays; offset++) {
+      const day = new Date(date.getTime());
+      day.setDate(day.getDate() + offset);
+      const dayDir = path.join(this.sessionsDir, this.toSessionDayKey(day));
+      if (isDirectory(dayDir)) {
+        dirs.push(dayDir);
+      }
+    }
+
+    return dirs;
+  }
+
+  private toSessionDayKey(date: Date): string {
+    const yyyy = String(date.getFullYear()).padStart(4, "0");
+    const mm = String(date.getMonth() + 1).padStart(2, "0");
+    const dd = String(date.getDate()).padStart(2, "0");
+    return path.join(yyyy, mm, dd);
+  }
+
+  private tryParseUuidV7Date(sessionId: string): Date | null {
+    const match = sessionId.match(
+      /^([0-9a-f]{8})-([0-9a-f]{4})-7[0-9a-f]{3}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+    );
+    if (!match) return null;
+
+    const timestampMs = Number.parseInt(`${match[1]}${match[2]}`, 16);
+    if (!Number.isSafeInteger(timestampMs) || timestampMs <= 0) return null;
+
+    const date = new Date(timestampMs);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+
+  private collectSessionFilesInDateDirs(dateDirs: string[]): string[] {
+    const out: string[] = [];
+
+    for (const dayDir of dateDirs) {
+      for (const fileEntry of safeReaddir(dayDir)) {
+        if (!fileEntry.endsWith(".jsonl")) continue;
+        out.push(path.join(dayDir, fileEntry));
+      }
+    }
+
+    return out;
+  }
+}

package/src/providers/codex/CodexSessionMapping.ts

@@ -0,0 +1,89 @@
+import * as fs from "fs";
+import * as path from "path";
+import type { ProcessInfo } from "../../adapters/AgentAdapter.js";
+import { safeReadFile } from "../../utils/session.js";
+
+export interface CodexSessionMappingOptions {
+  mappingPath?: string;
+  sessionsDir?: string;
+}
+
+export interface CodexSessionMappingMatch {
+  process: ProcessInfo;
+  filePath: string;
+}
+
+export interface CodexSessionMappingResult {
+  matches: CodexSessionMappingMatch[];
+  fallback: ProcessInfo[];
+}
+
+export class CodexSessionMapping {
+  private readonly mappingPath: string;
+  private readonly sessionsDir: string;
+
+  constructor(options: CodexSessionMappingOptions = {}) {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    this.mappingPath =
+      options.mappingPath ?? path.join(homeDir, ".codex", "ai-devkit", "sessions.json");
+    this.sessionsDir = options.sessionsDir ?? path.join(homeDir, ".codex", "sessions");
+  }
+
+  match(processes: ProcessInfo[]): CodexSessionMappingResult {
+    const mapping = this.read();
+    if (mapping.size === 0) return { matches: [], fallback: processes };
+
+    const matches: CodexSessionMappingMatch[] = [];
+    const fallback: ProcessInfo[] = [];
+
+    for (const processInfo of processes) {
+      const filePath = mapping.get(processInfo.pid);
+      if (!filePath || !this.isTrustedSessionPath(filePath) || !fs.existsSync(filePath)) {
+        fallback.push(processInfo);
+        continue;
+      }
+
+      matches.push({ process: processInfo, filePath });
+    }
+
+    return { matches, fallback };
+  }
+
+  private read(): Map<number, string> {
+    const content = safeReadFile(this.mappingPath);
+    if (content === undefined) return new Map();
+
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(content);
+    } catch {
+      return new Map();
+    }
+
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return new Map();
+
+    const map = new Map<number, string>();
+    for (const [key, value] of Object.entries(parsed)) {
+      const pid = this.toPid(key);
+      if (pid !== null && typeof value === "string" && value) {
+        map.set(pid, value);
+      }
+    }
+
+    return map;
+  }
+
+  private toPid(value: unknown): number | null {
+    if (typeof value === "number" && Number.isInteger(value) && value > 0) return value;
+    if (typeof value !== "string" || !/^\d+$/.test(value)) return null;
+
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : null;
+  }
+
+  private isTrustedSessionPath(filePath: string): boolean {
+    const resolvedRoot = path.resolve(this.sessionsDir);
+    const resolvedPath = path.resolve(filePath);
+    return resolvedPath === resolvedRoot || resolvedPath.startsWith(`${resolvedRoot}${path.sep}`);
+  }
+}