@ai-devkit/agent-manager 0.29.0 → 0.31.0

package/src/index.ts

@@ -6,7 +6,7 @@ export type {
     CapacityWindow,
 } from './capacity/index.js';
 
-export { ClaudeCodeAdapter } from './adapters/ClaudeCodeAdapter.js';
+export { ClaudeCodeAdapter } from './providers/claude/ClaudeCodeAdapter.js';
 export { CodexAdapter } from './adapters/CodexAdapter.js';
 export { CopilotAdapter } from './adapters/CopilotAdapter.js';
 export { GeminiCliAdapter } from './adapters/GeminiCliAdapter.js';
@@ -29,9 +29,6 @@ export { TerminalFocusManager, TerminalType } from './terminal/TerminalFocusMana
 export type { TerminalLocation } from './terminal/TerminalFocusManager.js';
 export { TtyWriter } from './terminal/TtyWriter.js';
 
-export { getProcessTty } from './utils/process.js';
-export { captureProcessSnapshot, executableBasename, filterByProcessNames } from './utils/process.js';
-export type { AgentSortKey } from './utils/sortAgents.js';
 export type { ListAgentsOptions } from './AgentManager.js';
 
 export { AgentRegistry, RenameNotFoundError, RenameConflictError } from './utils/AgentRegistry.js';
@@ -51,34 +48,53 @@ export {
     DurableAgentRepositoryError,
     DurableAgentNameConflictError,
     ClaudePrintError,
+    CodexPrintError,
+    PiPrintError,
 } from './durable/DurableAgent.js';
 export type {
     DurableAgent,
+    DurableAgentBase,
+    ClaudeDurableAgent,
+    CodexDurableAgent,
+    PiDurableAgent,
+    DurableProvider,
+    CodexPrintErrorCode,
     DurableAgentState,
     DurableSessionHealth,
     DurableRunStatus,
     DurableActiveRun,
     DurableLastResult,
+    PiPrintErrorCode,
     ProcessIdentity,
 } from './durable/DurableAgent.js';
 export { DurableAgentRepository } from './durable/DurableAgentRepository.js';
-export { LocalProcessInspector } from './durable/DurableAgentRepository.js';
 export type {
     CreateDurableAgentInput,
     DurableAgentRepositoryOptions,
     ProcessInspector,
     DurableRunCompletion,
 } from './durable/DurableAgentRepository.js';
-export { ClaudeCliProbe } from './durable/ClaudeCliProbe.js';
-export type { ClaudeCliProbeOptions } from './durable/ClaudeCliProbe.js';
-export { ClaudePrintRunner } from './durable/ClaudePrintRunner.js';
-export type {
-    ClaudePrintRunnerOptions,
-    ClaudePrintRunRequest,
-    ClaudePrintRunResult,
-} from './durable/ClaudePrintRunner.js';
-export { ClaudePrintAgentService } from './durable/ClaudePrintAgentService.js';
+export { ClaudePrintAgentService } from './providers/claude/durable/ClaudePrintAgentService.js';
 export type {
     ClaudePrintAgentServiceOptions,
     ClaudePrintSendResult,
-} from './durable/ClaudePrintAgentService.js';
+} from './providers/claude/durable/ClaudePrintAgentService.js';
+export { CodexCliProbe } from './providers/codex/durable/CodexCliProbe.js';
+export type { CodexCliProbeOptions } from './providers/codex/durable/CodexCliProbe.js';
+export { CodexPrintRunner } from './providers/codex/durable/CodexPrintRunner.js';
+export type {
+    CodexPrintRunnerOptions,
+    CodexPrintRunRequest,
+    CodexPrintRunResult,
+} from './providers/codex/durable/CodexPrintRunner.js';
+export { CodexPrintAgentService } from './providers/codex/durable/CodexPrintAgentService.js';
+export type {
+    CodexPrintAgentServiceOptions,
+    CodexPrintSendResult,
+} from './providers/codex/durable/CodexPrintAgentService.js';
+export { PiCliProbe } from './providers/pi/durable/PiCliProbe.js';
+export type { PiCliProbeOptions } from './providers/pi/durable/PiCliProbe.js';
+export { PiPrintRunner } from './providers/pi/durable/PiPrintRunner.js';
+export type { PiPrintRunnerOptions, PiPrintRunRequest, PiPrintRunResult } from './providers/pi/durable/PiPrintRunner.js';
+export { PiPrintAgentService } from './providers/pi/durable/PiPrintAgentService.js';
+export type { PiPrintAgentServiceOptions, PiPrintSendResult } from './providers/pi/durable/PiPrintAgentService.js';

package/src/providers/claude/ClaudeAgentMapper.ts

@@ -0,0 +1,62 @@
+import type { AgentInfo, ProcessInfo } from '../../adapters/AgentAdapter.js';
+import { AgentStatus } from '../../adapters/AgentAdapter.js';
+import { generateAgentName } from '../../utils/matching.js';
+import type { SessionFile } from '../../utils/session.js';
+import { ClaudeSessionParser, type ClaudeSession } from './ClaudeSessionParser.js';
+
+export interface ClaudeAgentLiveInfo {
+    pidStatus?: AgentStatus;
+    waitingFor?: string;
+}
+
+export interface ClaudeSessionAgentInput {
+    session: ClaudeSession;
+    processInfo: ProcessInfo;
+    sessionFile: SessionFile;
+    liveInfo?: ClaudeAgentLiveInfo;
+}
+
+export class ClaudeAgentMapper {
+    constructor(private readonly parser: ClaudeSessionParser = new ClaudeSessionParser()) {}
+
+    mapSessionToAgent({
+        session,
+        processInfo,
+        sessionFile,
+        liveInfo,
+    }: ClaudeSessionAgentInput): AgentInfo {
+        // Live PID-file status is authoritative when present — JSONL-derived
+        // status mis-classifies sessions whose latest entry is a UI-state
+        // event like `permission-mode` or `ai-title`.
+        const status = liveInfo?.pidStatus ?? this.parser.determineStatus(session);
+        const baseSummary = session.lastUserMessage || 'Session started';
+        const summary = status === AgentStatus.WAITING && liveInfo?.waitingFor
+            ? `${baseSummary} — waiting for ${liveInfo.waitingFor}`
+            : baseSummary;
+
+        return {
+            name: generateAgentName(processInfo.cwd, processInfo.pid),
+            type: 'claude',
+            status,
+            summary,
+            pid: processInfo.pid,
+            projectPath: sessionFile.resolvedCwd || processInfo.cwd || '',
+            sessionId: sessionFile.sessionId,
+            lastActive: session.lastActive,
+            sessionFilePath: sessionFile.filePath,
+        };
+    }
+
+    mapProcessOnlyAgent(processInfo: ProcessInfo): AgentInfo {
+        return {
+            name: generateAgentName(processInfo.cwd || '', processInfo.pid),
+            type: 'claude',
+            status: AgentStatus.IDLE,
+            summary: 'Unknown',
+            pid: processInfo.pid,
+            projectPath: processInfo.cwd || '',
+            sessionId: `pid-${processInfo.pid}`,
+            lastActive: new Date(),
+        };
+    }
+}

package/src/providers/claude/ClaudeCodeAdapter.ts

@@ -0,0 +1,160 @@
+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 { safeStat } from '../../utils/session.js';
+import { ClaudeSessionParser } from './ClaudeSessionParser.js';
+import { ClaudeAgentMapper } from './ClaudeAgentMapper.js';
+import { ClaudeSessionLocator } from './ClaudeSessionLocator.js';
+
+/**
+ * Claude Code Adapter
+ *
+ * Detects Claude Code agents by:
+ * 1. Filtering Claude processes from a shared asynchronous process snapshot
+ * 2. Using snapshot CWD and start-time enrichment
+ * 3. Attempting authoritative PID-file matching via ~/.claude/sessions/<pid>.json
+ * 4. Falling back to CWD+birthtime heuristic (matchProcessesToSessions) for processes without a PID file
+ * 5. Extracting summary from last user message in session JSONL
+ */
+export class ClaudeCodeAdapter implements AgentAdapter {
+    readonly type = 'claude' as const;
+    readonly processNames = ['claude'] as const;
+
+    private parser: ClaudeSessionParser;
+    private mapper: ClaudeAgentMapper;
+    private projectsDir: string;
+    private sessionsDir: string;
+
+    constructor() {
+        const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+        this.projectsDir = path.join(homeDir, '.claude', 'projects');
+        this.sessionsDir = path.join(homeDir, '.claude', 'sessions');
+        this.parser = new ClaudeSessionParser();
+        this.mapper = new ClaudeAgentMapper(this.parser);
+    }
+
+    canHandle(processInfo: ProcessInfo): boolean {
+        return this.isClaudeExecutable(processInfo.command);
+    }
+
+    private isClaudeExecutable(command: string): boolean {
+        const base = executableBasename(command);
+        return base === 'claude' || base === 'claude.exe';
+    }
+
+    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 { direct, legacyMatches } = this.createLocator().matchRunningProcesses(processes);
+
+        const matchedPids = new Set([
+            ...direct.map((d) => d.process.pid),
+            ...legacyMatches.map((m) => m.process.pid),
+        ]);
+
+        const agents: AgentInfo[] = [];
+
+        // Build agents from direct (resume + PID-file) matches
+        for (const match of direct) {
+            const { process: proc, sessionFile } = match;
+            const sessionData = this.parser.readSession(sessionFile.filePath, sessionFile.resolvedCwd);
+            if (sessionData) {
+                agents.push(this.mapper.mapSessionToAgent({
+                    session: sessionData,
+                    processInfo: proc,
+                    sessionFile,
+                    liveInfo: {
+                        pidStatus: match.pidStatus,
+                        waitingFor: match.waitingFor,
+                    },
+                }));
+            } else {
+                matchedPids.delete(proc.pid);
+            }
+        }
+
+        // Build agents from legacy matches
+        for (const match of legacyMatches) {
+            const sessionData = this.parser.readSession(
+                match.session.filePath,
+                match.session.resolvedCwd,
+            );
+            if (sessionData) {
+                agents.push(this.mapper.mapSessionToAgent({
+                    session: sessionData,
+                    processInfo: match.process,
+                    sessionFile: match.session,
+                }));
+            } else {
+                matchedPids.delete(match.process.pid);
+            }
+        }
+
+        // Any process with no match (direct or legacy) appears as IDLE
+        for (const proc of processes) {
+            if (!matchedPids.has(proc.pid)) {
+                agents.push(this.mapper.mapProcessOnlyAgent(proc));
+            }
+        }
+
+        return agents;
+    }
+
+    private createLocator(): ClaudeSessionLocator {
+        return new ClaudeSessionLocator({
+            projectsDir: this.projectsDir,
+            sessionsDir: this.sessionsDir,
+        });
+    }
+
+    getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {
+        return this.parser.getConversation(sessionFilePath, options);
+    }
+
+    async listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]> {
+        const filterCwd = opts?.cwd;
+        const candidates = this.createLocator().discoverHistoricalSessionFiles();
+        const summaries: SessionSummary[] = [];
+
+        for (const { filePath, defaultCwd } of candidates) {
+            const session = this.parser.readSession(filePath, defaultCwd);
+            if (!session) continue;
+
+            // Drop sessions whose JSONL had no parseable conversation entries.
+            // readSession is permissive (returns a shell record even when every
+            // line fails to parse); listSessions needs at least one real entry
+            // so we don't surface garbage files.
+            if (!session.lastEntryType) continue;
+
+            const recordedCwd = session.lastCwd || defaultCwd;
+            if (filterCwd !== undefined && recordedCwd !== filterCwd) continue;
+
+            const stat = safeStat(filePath);
+
+            summaries.push({
+                type: 'claude',
+                sessionId: session.sessionId,
+                cwd: recordedCwd,
+                firstUserMessage: session.firstUserMessage || '',
+                lastActive: session.lastActive ?? stat?.mtime ?? new Date(),
+                startedAt: session.sessionStart ?? stat?.birthtime ?? stat?.mtime ?? new Date(),
+                sessionFilePath: filePath,
+            });
+        }
+
+        return summaries;
+    }
+}