@ai-devkit/agent-manager 0.15.0 → 0.17.0

package/src/adapters/CodexAdapter.ts

@@ -25,6 +25,7 @@ import { listAgentProcesses, enrichProcesses } from '../utils/process.js';
 import { batchGetSessionFileBirthtimes, isDirectory, safeReadFile, safeReaddir, safeStat } from '../utils/session.js';
 import type { SessionFile } from '../utils/session.js';
 import { matchProcessesToSessions, generateAgentName } from '../utils/matching.js';
+import { AgentRegistry } from '../utils/AgentRegistry.js';
 
 interface CodexEventEntry {
     timestamp?: string;
@@ -47,6 +48,16 @@ interface CodexSession {
     lastPayloadType?: string;
 }
 
+interface DirectMatch {
+    process: ProcessInfo;
+    sessionFile: SessionFile;
+}
+
+interface DirectMatchResult {
+    agents: AgentInfo[];
+    failedProcesses: ProcessInfo[];
+}
+
 export class CodexAdapter implements AgentAdapter {
     readonly type = 'codex' as const;
 
@@ -55,10 +66,12 @@ export class CodexAdapter implements AgentAdapter {
     private static readonly PROCESS_START_DAY_WINDOW_DAYS = 1;
 
     private codexSessionsDir: string;
+    private registry: AgentRegistry;
 
-    constructor() {
+    constructor(registry: AgentRegistry = AgentRegistry.default()) {
         const homeDir = process.env.HOME || process.env.USERPROFILE || '';
         this.codexSessionsDir = path.join(homeDir, '.codex', 'sessions');
+        this.registry = registry;
     }
 
     canHandle(processInfo: ProcessInfo): boolean {
@@ -72,14 +85,27 @@ export class CodexAdapter implements AgentAdapter {
         const processes = enrichProcesses(listAgentProcesses('codex'));
         if (processes.length === 0) return [];
 
-        const { sessions, contentCache } = this.discoverSessions(processes);
+        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: AgentInfo[] = [];
+        const matches = matchProcessesToSessions(fallback, sessions);
+        const matchedPids = new Set([
+            ...directResult.agents.map((a) => a.pid),
+            ...matches.map((m) => m.process.pid),
+        ]);
+        const agents: AgentInfo[] = [...directResult.agents];
 
         for (const match of matches) {
             const cachedContent = contentCache.get(match.session.filePath);
@@ -91,13 +117,134 @@ export class CodexAdapter implements AgentAdapter {
             }
         }
 
-        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];
+    }
+
+    private tryRegistryCache(processes: ProcessInfo[]): {
+        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 (
+                !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.
+     */
+    private tryResumeMatching(processes: ProcessInfo[]): {
+        direct: DirectMatch[];
+        fallback: ProcessInfo[];
+    } {
+        const direct: DirectMatch[] = [];
+        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 };
+    }
+
+    private extractResumeSessionId(command: string): string | null {
+        const match = command.match(/(?:^|\s)resume\s+([0-9a-f-]{36})(?:\s|$)/i);
+        return match?.[1] ?? null;
+    }
+
+    private findSessionFileById(sessionId: string): SessionFile | null {
+        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) as CodexEventEntry;
+                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;
+    }
+
+    private mapDirectMatches(matches: DirectMatch[]): DirectMatchResult {
+        const agents: AgentInfo[] = [];
+        const failedProcesses: ProcessInfo[] = [];
+
+        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 };
     }
 
     /**

package/src/adapters/CopilotAdapter.ts

@@ -0,0 +1,453 @@
+/**
+ * Copilot Adapter
+ *
+ * Detects running GitHub Copilot CLI agents by:
+ * 1. Finding running copilot processes via shared listAgentProcesses()
+ * 2. Enriching with CWD and start times via shared enrichProcesses()
+ * 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,
+} from './AgentAdapter.js';
+import { AgentStatus } from './AgentAdapter.js';
+import { enrichProcesses, listAgentProcesses } from '../utils/process.js';
+import { generateAgentName } from '../utils/matching.js';
+import { isDirectory, safeReadFile, safeReaddir, 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;
+}
+
+interface CopilotSession {
+    sessionId: string;
+    projectPath: string;
+    summary: string;
+    sessionStart: Date;
+    lastActive: Date;
+    lastEventType?: string;
+    firstUserMessage: string;
+    eventsFilePath: string;
+}
+
+interface CopilotLock {
+    sessionDir: string;
+    sessionId: string;
+    pid: number;
+}
+
+interface CopilotSessionDir {
+    sessionDir: string;
+    sessionId: string;
+}
+
+interface CopilotEventSummary {
+    sessionId: string;
+    projectPath: string;
+    sessionStart: Date;
+    lastActive: Date;
+    firstUserMessage: string;
+    lastText: string;
+    lastEventType?: string;
+}
+
+export class CopilotAdapter implements AgentAdapter {
+    readonly type = 'copilot' as const;
+
+    private static readonly IDLE_THRESHOLD_MINUTES = 5;
+    private static readonly VERBOSE_SYSTEM_EVENTS = new Set([
+        'system.message',
+        'session.info',
+        'session.warning',
+        'tool.execution_start',
+        'tool.execution_complete',
+        'function',
+        'abort',
+    ]);
+    private static readonly WAITING_EVENTS = new Set([
+        'assistant.message',
+        'assistant.turn_end',
+        'session.shutdown',
+        'abort',
+    ]);
+
+    private sessionStateDir: string;
+
+    constructor() {
+        const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+        this.sessionStateDir = path.join(homeDir, '.copilot', 'session-state');
+    }
+
+    canHandle(processInfo: ProcessInfo): boolean {
+        return this.isCopilotExecutable(processInfo.command);
+    }
+
+    async detectAgents(): Promise<AgentInfo[]> {
+        const processes = enrichProcesses(listAgentProcesses('copilot'));
+        if (processes.length === 0) return [];
+
+        const processByPid = new Map(processes.map((proc) => [proc.pid, proc]));
+        const matchedPids = new Set<number>();
+        const matchedProcesses: ProcessInfo[] = [];
+        const agents: AgentInfo[] = [];
+
+        for (const lock of this.discoverActiveLocks()) {
+            const proc = processByPid.get(lock.pid);
+            if (!proc) continue;
+
+            const session = this.readSessionDir(lock.sessionDir, lock.sessionId);
+            if (!session) continue;
+
+            agents.push(this.mapSessionToAgent(session, proc));
+            matchedPids.add(proc.pid);
+            matchedProcesses.push(proc);
+        }
+
+        for (const proc of processes) {
+            if (!matchedPids.has(proc.pid) && !this.isDuplicateProcess(proc, matchedProcesses)) {
+                agents.push(this.mapProcessOnlyAgent(proc));
+            }
+        }
+
+        return agents;
+    }
+
+    private isDuplicateProcess(proc: ProcessInfo, matchedProcesses: ProcessInfo[]): boolean {
+        return matchedProcesses.some((matched) => {
+            if (proc.pid === matched.pid) return true;
+
+            const sameTty = proc.tty !== '' && proc.tty !== '?' && proc.tty === matched.tty;
+            const sameCwd = proc.cwd !== '' && proc.cwd === matched.cwd;
+
+            return sameTty && (sameCwd || proc.cwd === '' || matched.cwd === '');
+        });
+    }
+
+    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;
+    }
+
+    async listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]> {
+        const summaries: SessionSummary[] = [];
+
+        for (const { sessionDir, sessionId } of this.listSessionDirs()) {
+            const session = this.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 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;
+    }
+
+    private 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;
+    }
+
+    private readSessionDir(sessionDir: string, fallbackSessionId: string): CopilotSession | null {
+        const eventsFilePath = path.join(sessionDir, 'events.jsonl');
+        const workspace = this.readWorkspace(path.join(sessionDir, 'workspace.yaml'));
+        const entries = this.readEvents(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.summarizeEvents(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,
+        };
+    }
+
+    private readEvents(eventsFilePath: string): CopilotEventEntry[] {
+        const content = safeReadFile(eventsFilePath);
+        return content === undefined ? [] : this.parseEventLines(content);
+    }
+
+    private summarizeEvents(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 readWorkspace(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 && CopilotAdapter.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 mapSessionToAgent(session: CopilotSession, proc: ProcessInfo): AgentInfo {
+        const projectPath = session.projectPath || proc.cwd || '';
+        return {
+            name: generateAgentName(projectPath, proc.pid),
+            type: this.type,
+            status: this.determineStatus(session),
+            summary: session.summary || 'Copilot session active',
+            pid: proc.pid,
+            projectPath,
+            sessionId: session.sessionId,
+            lastActive: session.lastActive,
+            sessionFilePath: session.eventsFilePath,
+        };
+    }
+
+    private mapProcessOnlyAgent(proc: ProcessInfo): AgentInfo {
+        return {
+            name: generateAgentName(proc.cwd || '', proc.pid),
+            type: this.type,
+            status: AgentStatus.RUNNING,
+            summary: 'Copilot process running',
+            pid: proc.pid,
+            projectPath: proc.cwd || '',
+            sessionId: `pid-${proc.pid}`,
+            lastActive: new Date(),
+        };
+    }
+
+    private determineStatus(session: CopilotSession): AgentStatus {
+        const diffMs = Date.now() - session.lastActive.getTime();
+        const diffMinutes = diffMs / 60000;
+        if (diffMinutes > CopilotAdapter.IDLE_THRESHOLD_MINUTES) {
+            return AgentStatus.IDLE;
+        }
+
+        if (session.lastEventType !== undefined && CopilotAdapter.WAITING_EVENTS.has(session.lastEventType)) {
+            return AgentStatus.WAITING;
+        }
+
+        return AgentStatus.RUNNING;
+    }
+
+    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)}...`;
+    }
+
+    private isCopilotExecutable(command: string): boolean {
+        const executable = command.trim().split(/\s+/)[0] || '';
+        const base = path.basename(executable).toLowerCase();
+        return base === 'copilot' || base === 'copilot.exe';
+    }
+}