@ai-devkit/agent-manager 0.15.0 → 0.17.0

package/dist/adapters/CodexAdapter.js

@@ -8,56 +8,174 @@
  * 4. Setting resolvedCwd from session_meta first line
  * 5. Matching sessions to processes via shared matchProcessesToSessions()
  * 6. Extracting summary from last event entry in session JSONL
- */
-import * as fs from 'fs';
+ */ import * as fs from 'fs';
 import * as path from 'path';
 import { AgentStatus } from './AgentAdapter.js';
 import { listAgentProcesses, enrichProcesses } from '../utils/process.js';
 import { batchGetSessionFileBirthtimes, isDirectory, safeReadFile, safeReaddir, safeStat } from '../utils/session.js';
 import { matchProcessesToSessions, generateAgentName } from '../utils/matching.js';
+import { AgentRegistry } from '../utils/AgentRegistry.js';
 export class CodexAdapter {
     type = 'codex';
     static IDLE_THRESHOLD_MINUTES = 5;
-    /** Include session files around process start day to recover long-lived processes. */
-    static PROCESS_START_DAY_WINDOW_DAYS = 1;
+    /** Include session files around process start day to recover long-lived processes. */ static PROCESS_START_DAY_WINDOW_DAYS = 1;
     codexSessionsDir;
-    constructor() {
+    registry;
+    constructor(registry = AgentRegistry.default()){
         const homeDir = process.env.HOME || process.env.USERPROFILE || '';
         this.codexSessionsDir = path.join(homeDir, '.codex', 'sessions');
+        this.registry = registry;
     }
     canHandle(processInfo) {
         return this.isCodexExecutable(processInfo.command);
     }
     /**
      * Detect running Codex agents
-     */
-    async detectAgents() {
+     */ async detectAgents() {
         const processes = enrichProcesses(listAgentProcesses('codex'));
-        if (processes.length === 0)
-            return [];
-        const { sessions, contentCache } = this.discoverSessions(processes);
+        if (processes.length === 0) return [];
+        const { cachedAgents, remaining } = this.tryRegistryCache(processes);
+        if (remaining.length === 0) return cachedAgents;
+        const { direct, fallback } = this.tryResumeMatching(remaining);
+        const directResult = this.mapDirectMatches(direct);
+        const { sessions, contentCache } = this.discoverSessions(fallback);
         if (sessions.length === 0) {
-            return processes.map((p) => this.mapProcessOnlyAgent(p));
+            return [
+                ...cachedAgents,
+                ...directResult.agents,
+                ...directResult.failedProcesses.map((p)=>this.mapProcessOnlyAgent(p)),
+                ...fallback.map((p)=>this.mapProcessOnlyAgent(p))
+            ];
         }
-        const matches = matchProcessesToSessions(processes, sessions);
-        const matchedPids = new Set(matches.map((m) => m.process.pid));
-        const agents = [];
-        for (const match of matches) {
+        const matches = matchProcessesToSessions(fallback, sessions);
+        const matchedPids = new Set([
+            ...directResult.agents.map((a)=>a.pid),
+            ...matches.map((m)=>m.process.pid)
+        ]);
+        const agents = [
+            ...directResult.agents
+        ];
+        for (const match of matches){
             const cachedContent = contentCache.get(match.session.filePath);
             const sessionData = this.parseSession(cachedContent, match.session.filePath);
             if (sessionData) {
                 agents.push(this.mapSessionToAgent(sessionData, match.process, match.session.filePath));
-            }
-            else {
+            } else {
                 matchedPids.delete(match.process.pid);
             }
         }
-        for (const proc of processes) {
+        for (const proc of fallback){
             if (!matchedPids.has(proc.pid)) {
                 agents.push(this.mapProcessOnlyAgent(proc));
             }
         }
-        return agents;
+        for (const proc of directResult.failedProcesses){
+            agents.push(this.mapProcessOnlyAgent(proc));
+        }
+        return [
+            ...cachedAgents,
+            ...agents
+        ];
+    }
+    tryRegistryCache(processes) {
+        const cachedAgents = [];
+        const remaining = [];
+        const byPid = new Map(this.registry.list().map((e)=>[
+                e.pid,
+                e
+            ]));
+        for (const proc of processes){
+            const entry = byPid.get(proc.pid);
+            if (!entry || entry.type !== this.type || !entry.sessionFilePath || !fs.existsSync(entry.sessionFilePath)) {
+                remaining.push(proc);
+                continue;
+            }
+            const content = safeReadFile(entry.sessionFilePath);
+            const sessionData = this.parseSession(content, entry.sessionFilePath);
+            if (!sessionData) {
+                remaining.push(proc);
+                continue;
+            }
+            cachedAgents.push(this.mapSessionToAgent(sessionData, proc, entry.sessionFilePath));
+        }
+        return {
+            cachedAgents,
+            remaining
+        };
+    }
+    /**
+     * Match processes via `codex resume <uuid>` in their command line.
+     * Resumed sessions predate the process, so birth-time proximity cannot
+     * reliably pair them with the running PID.
+     */ tryResumeMatching(processes) {
+        const direct = [];
+        const fallback = [];
+        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
+        };
+    }
+    extractResumeSessionId(command) {
+        const match = command.match(/(?:^|\s)resume\s+([0-9a-f-]{36})(?:\s|$)/i);
+        return match?.[1] ?? null;
+    }
+    findSessionFileById(sessionId) {
+        for (const filePath of this.collectAllSessionFiles()){
+            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);
+                if (parsed.type !== 'session_meta' || parsed.payload?.id !== sessionId) {
+                    continue;
+                }
+                const stat = safeStat(filePath);
+                if (!stat) continue;
+                return {
+                    sessionId,
+                    filePath,
+                    projectDir: path.dirname(filePath),
+                    birthtimeMs: stat.birthtimeMs,
+                    resolvedCwd: parsed.payload.cwd || ''
+                };
+            } catch  {
+                continue;
+            }
+        }
+        return null;
+    }
+    mapDirectMatches(matches) {
+        const agents = [];
+        const failedProcesses = [];
+        for (const match of matches){
+            const sessionData = this.parseSession(undefined, match.sessionFile.filePath);
+            if (sessionData) {
+                agents.push(this.mapSessionToAgent(sessionData, match.process, match.sessionFile.filePath));
+            } else {
+                failedProcesses.push(match.process);
+            }
+        }
+        return {
+            agents,
+            failedProcesses
+        };
     }
     /**
      * Discover session files for the given processes.
@@ -66,18 +184,18 @@ export class CodexAdapter {
      * to scan (±1 day window), then batches stat calls across all directories.
      * Reads each file once and caches content for later parsing by parseSession().
      * Sets resolvedCwd from session_meta first line.
-     */
-    discoverSessions(processes) {
-        const empty = { sessions: [], contentCache: new Map() };
-        if (!fs.existsSync(this.codexSessionsDir))
-            return empty;
+     */ discoverSessions(processes) {
+        const empty = {
+            sessions: [],
+            contentCache: new Map()
+        };
+        if (!fs.existsSync(this.codexSessionsDir)) return empty;
         const dateDirs = this.getDateDirs(processes);
-        if (dateDirs.length === 0)
-            return empty;
+        if (dateDirs.length === 0) return empty;
         const files = batchGetSessionFileBirthtimes(dateDirs);
         const contentCache = new Map();
         // Read each file once: extract CWD for matching, cache content for later parsing
-        for (const file of files) {
+        for (const file of files){
             try {
                 const content = fs.readFileSync(file.filePath, 'utf-8');
                 contentCache.set(file.filePath, content);
@@ -88,37 +206,37 @@ export class CodexAdapter {
                         file.resolvedCwd = parsed.payload?.cwd || '';
                     }
                 }
-            }
-            catch {
-                // Skip unreadable files
+            } catch  {
+            // Skip unreadable files
             }
         }
-        return { sessions: files, contentCache };
+        return {
+            sessions: files,
+            contentCache
+        };
     }
     /**
      * Determine which date directories to scan based on process start times.
      * Returns only directories that actually exist.
-     */
-    getDateDirs(processes) {
+     */ getDateDirs(processes) {
         const dayKeys = new Set();
         const window = CodexAdapter.PROCESS_START_DAY_WINDOW_DAYS;
-        for (const proc of processes) {
+        for (const proc of processes){
             const startTime = proc.startTime || new Date();
-            for (let offset = -window; offset <= window; offset++) {
+            for(let offset = -window; offset <= window; offset++){
                 const day = new Date(startTime.getTime());
                 day.setDate(day.getDate() + offset);
                 dayKeys.add(this.toSessionDayKey(day));
             }
         }
         const dirs = [];
-        for (const dayKey of dayKeys) {
+        for (const dayKey of dayKeys){
             const dayDir = path.join(this.codexSessionsDir, dayKey);
             try {
                 if (fs.statSync(dayDir).isDirectory()) {
                     dirs.push(dayDir);
                 }
-            }
-            catch {
+            } catch  {
                 continue;
             }
         }
@@ -133,56 +251,47 @@ export class CodexAdapter {
     /**
      * Parse session file content into CodexSession.
      * Uses cached content if available, otherwise reads from disk.
-     */
-    parseSession(cachedContent, filePath) {
+     */ parseSession(cachedContent, filePath) {
         let content;
         if (cachedContent !== undefined) {
             content = cachedContent;
-        }
-        else {
+        } else {
             try {
                 content = fs.readFileSync(filePath, 'utf-8');
-            }
-            catch {
+            } catch  {
                 return null;
             }
         }
         const allLines = content.trim().split('\n');
-        if (!allLines[0])
-            return null;
+        if (!allLines[0]) return null;
         let metaEntry;
         try {
             metaEntry = JSON.parse(allLines[0]);
-        }
-        catch {
+        } catch  {
             return null;
         }
         if (metaEntry.type !== 'session_meta' || !metaEntry.payload?.id) {
             return null;
         }
         const entries = [];
-        for (const line of allLines) {
+        for (const line of allLines){
             try {
                 entries.push(JSON.parse(line));
-            }
-            catch {
+            } catch  {
                 continue;
             }
         }
         const lastEntry = this.findLastEventEntry(entries);
         const lastPayloadType = lastEntry?.payload?.type;
-        const lastActive = this.parseTimestamp(lastEntry?.timestamp) ||
-            this.parseTimestamp(metaEntry.payload.timestamp) ||
-            fs.statSync(filePath).mtime;
-        const sessionStart = this.parseTimestamp(metaEntry.payload.timestamp) ||
-            lastActive;
+        const lastActive = this.parseTimestamp(lastEntry?.timestamp) || this.parseTimestamp(metaEntry.payload.timestamp) || fs.statSync(filePath).mtime;
+        const sessionStart = this.parseTimestamp(metaEntry.payload.timestamp) || lastActive;
         return {
             sessionId: metaEntry.payload.id,
             projectPath: metaEntry.payload.cwd || '',
             summary: this.extractSummary(entries),
             sessionStart,
             lastActive,
-            lastPayloadType,
+            lastPayloadType
         };
     }
     mapSessionToAgent(session, processInfo, filePath) {
@@ -195,7 +304,7 @@ export class CodexAdapter {
             projectPath: session.projectPath || processInfo.cwd || '',
             sessionId: session.sessionId,
             lastActive: session.lastActive,
-            sessionFilePath: filePath,
+            sessionFilePath: filePath
         };
     }
     mapProcessOnlyAgent(processInfo) {
@@ -207,11 +316,11 @@ export class CodexAdapter {
             pid: processInfo.pid,
             projectPath: processInfo.cwd || '',
             sessionId: `pid-${processInfo.pid}`,
-            lastActive: new Date(),
+            lastActive: new Date()
         };
     }
     findLastEventEntry(entries) {
-        for (let i = entries.length - 1; i >= 0; i--) {
+        for(let i = entries.length - 1; i >= 0; i--){
             const entry = entries[i];
             if (entry && typeof entry.type === 'string') {
                 return entry;
@@ -220,8 +329,7 @@ export class CodexAdapter {
         return undefined;
     }
     parseTimestamp(value) {
-        if (!value)
-            return null;
+        if (!value) return null;
         const timestamp = new Date(value);
         return Number.isNaN(timestamp.getTime()) ? null : timestamp;
     }
@@ -231,15 +339,13 @@ export class CodexAdapter {
         if (diffMinutes > CodexAdapter.IDLE_THRESHOLD_MINUTES) {
             return AgentStatus.IDLE;
         }
-        if (session.lastPayloadType === 'agent_message' ||
-            session.lastPayloadType === 'task_complete' ||
-            session.lastPayloadType === 'turn_aborted') {
+        if (session.lastPayloadType === 'agent_message' || session.lastPayloadType === 'task_complete' || session.lastPayloadType === 'turn_aborted') {
             return AgentStatus.WAITING;
         }
         return AgentStatus.RUNNING;
     }
     extractSummary(entries) {
-        for (let i = entries.length - 1; i >= 0; i--) {
+        for(let i = entries.length - 1; i >= 0; i--){
             const message = entries[i]?.payload?.message;
             if (typeof message === 'string' && message.trim().length > 0) {
                 return this.truncate(message.trim(), 120);
@@ -248,8 +354,7 @@ export class CodexAdapter {
         return 'Codex session active';
     }
     truncate(value, maxLength) {
-        if (value.length <= maxLength)
-            return value;
+        if (value.length <= maxLength) return value;
         return `${value.slice(0, maxLength - 3)}...`;
     }
     isCodexExecutable(command) {
@@ -261,62 +366,50 @@ export class CodexAdapter {
      * Read the full conversation from a Codex session JSONL file.
      *
      * Codex entries use payload.type to indicate message role and payload.message for content.
-     */
-    getConversation(sessionFilePath, options) {
+     */ getConversation(sessionFilePath, options) {
         const verbose = options?.verbose ?? false;
         const content = safeReadFile(sessionFilePath);
-        if (content === undefined)
-            return [];
+        if (content === undefined) return [];
         const lines = content.trim().split('\n');
         const messages = [];
-        for (const line of lines) {
+        for (const line of lines){
             let entry;
             try {
                 entry = JSON.parse(line);
-            }
-            catch {
+            } catch  {
                 continue;
             }
-            if (entry.type === 'session_meta')
-                continue;
+            if (entry.type === 'session_meta') continue;
             const payloadType = entry.payload?.type;
-            if (!payloadType)
-                continue;
+            if (!payloadType) continue;
             let role;
             if (payloadType === 'user_message') {
                 role = 'user';
-            }
-            else if (payloadType === 'agent_message' || payloadType === 'task_complete') {
+            } else if (payloadType === 'agent_message' || payloadType === 'task_complete') {
                 role = 'assistant';
-            }
-            else if (verbose) {
+            } else if (verbose) {
                 role = 'system';
-            }
-            else {
+            } else {
                 continue;
             }
             const text = entry.payload?.message?.trim();
-            if (!text)
-                continue;
+            if (!text) continue;
             messages.push({
                 role,
                 content: text,
-                timestamp: entry.timestamp,
+                timestamp: entry.timestamp
             });
         }
         return messages;
     }
     async listSessions(opts) {
-        if (!isDirectory(this.codexSessionsDir))
-            return [];
+        if (!isDirectory(this.codexSessionsDir)) return [];
         const files = this.collectAllSessionFiles();
         const summaries = [];
-        for (const filePath of files) {
+        for (const filePath of files){
             const summary = this.fileToSessionSummary(filePath);
-            if (!summary)
-                continue;
-            if (opts?.cwd !== undefined && summary.cwd !== opts.cwd)
-                continue;
+            if (!summary) continue;
+            if (opts?.cwd !== undefined && summary.cwd !== opts.cwd) continue;
             summaries.push(summary);
         }
         return summaries;
@@ -325,24 +418,19 @@ export class CodexAdapter {
      * Walk every YYYY/MM/DD directory under `codexSessionsDir` and return
      * absolute paths of `.jsonl` files. Tolerates malformed layouts
      * (skips entries that aren't directories at the expected depth).
-     */
-    collectAllSessionFiles() {
+     */ collectAllSessionFiles() {
         const out = [];
-        for (const yearEntry of safeReaddir(this.codexSessionsDir)) {
+        for (const yearEntry of safeReaddir(this.codexSessionsDir)){
             const yearDir = path.join(this.codexSessionsDir, yearEntry);
-            if (!isDirectory(yearDir))
-                continue;
-            for (const monthEntry of safeReaddir(yearDir)) {
+            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)) {
+                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;
+                    if (!isDirectory(dayDir)) continue;
+                    for (const fileEntry of safeReaddir(dayDir)){
+                        if (!fileEntry.endsWith('.jsonl')) continue;
                         out.push(path.join(dayDir, fileEntry));
                     }
                 }
@@ -354,19 +442,15 @@ export class CodexAdapter {
      * Read a Codex session JSONL file and produce a {@link SessionSummary}.
      * Returns null when the file is unreadable, has no `session_meta`, or
      * lacks a session id.
-     */
-    fileToSessionSummary(filePath) {
+     */ fileToSessionSummary(filePath) {
         const content = safeReadFile(filePath);
-        if (content === undefined)
-            return null;
+        if (content === undefined) return null;
         const allLines = content.trim().split('\n');
-        if (!allLines[0])
-            return null;
+        if (!allLines[0]) return null;
         let metaEntry;
         try {
             metaEntry = JSON.parse(allLines[0]);
-        }
-        catch {
+        } catch  {
             return null;
         }
         if (metaEntry.type !== 'session_meta' || !metaEntry.payload?.id) {
@@ -374,30 +458,21 @@ export class CodexAdapter {
         }
         let firstUserMessage = '';
         let lastTimestamp = null;
-        for (let i = 1; i < allLines.length; i++) {
+        for(let i = 1; i < allLines.length; i++){
             let entry;
             try {
                 entry = JSON.parse(allLines[i]);
-            }
-            catch {
+            } catch  {
                 continue;
             }
             const ts = this.parseTimestamp(entry.timestamp);
-            if (ts)
-                lastTimestamp = ts;
-            if (!firstUserMessage &&
-                entry.payload?.type === 'user_message' &&
-                typeof entry.payload.message === 'string' &&
-                entry.payload.message.trim().length > 0) {
+            if (ts) lastTimestamp = ts;
+            if (!firstUserMessage && entry.payload?.type === 'user_message' && typeof entry.payload.message === 'string' && entry.payload.message.trim().length > 0) {
                 firstUserMessage = entry.payload.message.trim();
             }
         }
         const stat = safeStat(filePath);
-        const startedAt = this.parseTimestamp(metaEntry.payload.timestamp) ||
-            lastTimestamp ||
-            stat?.birthtime ||
-            stat?.mtime ||
-            new Date();
+        const startedAt = this.parseTimestamp(metaEntry.payload.timestamp) || lastTimestamp || stat?.birthtime || stat?.mtime || new Date();
         const lastActive = lastTimestamp || startedAt;
         return {
             type: 'codex',
@@ -406,8 +481,9 @@ export class CodexAdapter {
             firstUserMessage,
             lastActive,
             startedAt,
-            sessionFilePath: filePath,
+            sessionFilePath: filePath
         };
     }
 }
+
 //# sourceMappingURL=CodexAdapter.js.map