@ai-devkit/agent-manager 0.32.0 → 0.33.0

package/src/providers/codex/durable/CodexPrintRunner.ts

@@ -1,94 +1,104 @@
-import { spawn as nodeSpawn, type ChildProcessWithoutNullStreams, type SpawnOptionsWithoutStdio } from 'child_process';
-import type { CodexDurableAgent, ProcessIdentity } from '../../../durable/DurableAgent.js';
-import { CodexPrintError } from '../../../durable/DurableAgent.js';
-import { LocalProcessInspector, type ProcessInspector } from '../../../durable/process.js';
-import { waitForChildClose } from '../../../durable/utils.js';
-import { CodexStreamParser } from './CodexStreamParser.js';
+import {
+  spawn as nodeSpawn,
+  type ChildProcessWithoutNullStreams,
+  type SpawnOptionsWithoutStdio,
+} from "child_process";
+import type { CodexDurableAgent, ProcessIdentity } from "../../../durable/DurableAgent.js";
+import { CodexPrintError } from "../../../durable/DurableAgent.js";
+import { LocalProcessInspector, type ProcessInspector } from "../../../durable/process.js";
+import { waitForChildClose } from "../../../durable/utils.js";
+import { CodexStreamParser } from "./CodexStreamParser.js";
 
 type Spawn = (
-    command: string,
-    args: readonly string[],
-    options: SpawnOptionsWithoutStdio & { stdio: ['pipe', 'pipe', 'pipe'] },
+  command: string,
+  args: readonly string[],
+  options: SpawnOptionsWithoutStdio & { stdio: ["pipe", "pipe", "pipe"] },
 ) => ChildProcessWithoutNullStreams;
 
 export interface CodexPrintRunRequest {
-    agent: CodexDurableAgent;
-    prompt: string;
-    executable?: string;
-    onSpawn(identity: ProcessIdentity): Promise<void>;
-    onSession(providerSessionId: string): Promise<void>;
+  agent: CodexDurableAgent;
+  prompt: string;
+  executable?: string;
+  onSpawn(identity: ProcessIdentity): Promise<void>;
+  onSession(providerSessionId: string): Promise<void>;
 }
 
 export interface CodexPrintRunResult {
-    sessionId: string;
-    result: string;
-    messages: string[];
-    exitCode: number;
+  sessionId: string;
+  result: string;
+  messages: string[];
+  exitCode: number;
 }
 
 export interface CodexPrintRunnerOptions {
-    spawn?: Spawn;
-    processInspector?: ProcessInspector;
-    maxLineBytes?: number;
+  spawn?: Spawn;
+  processInspector?: ProcessInspector;
+  maxLineBytes?: number;
 }
 
 export class CodexPrintRunner {
-    private readonly spawn: Spawn;
-    private readonly processInspector: ProcessInspector;
-    private readonly maxLineBytes: number;
+  private readonly spawn: Spawn;
+  private readonly processInspector: ProcessInspector;
+  private readonly maxLineBytes: number;
 
-    constructor(options: CodexPrintRunnerOptions = {}) {
-        this.spawn = options.spawn ?? (nodeSpawn as Spawn);
-        this.processInspector = options.processInspector ?? new LocalProcessInspector();
-        this.maxLineBytes = options.maxLineBytes ?? 1024 * 1024;
-    }
+  constructor(options: CodexPrintRunnerOptions = {}) {
+    this.spawn = options.spawn ?? (nodeSpawn as Spawn);
+    this.processInspector = options.processInspector ?? new LocalProcessInspector();
+    this.maxLineBytes = options.maxLineBytes ?? 1024 * 1024;
+  }
 
-    async run(request: CodexPrintRunRequest): Promise<CodexPrintRunResult> {
-        const args = buildCodexExecArgs(request.agent);
-        const child = this.spawn(request.executable ?? 'codex', args, {
-            cwd: request.agent.cwd, shell: false, stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        const identity = this.verifyProcessIdentity(child);
+  async run(request: CodexPrintRunRequest): Promise<CodexPrintRunResult> {
+    const args = buildCodexExecArgs(request.agent);
+    const child = this.spawn(request.executable ?? "codex", args, {
+      cwd: request.agent.cwd,
+      shell: false,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    const identity = this.verifyProcessIdentity(child);
 
-        const parser = new CodexStreamParser(request.agent.providerSessionId, request.onSession, this.maxLineBytes);
-        let processing = Promise.resolve();
+    const parser = new CodexStreamParser(
+      request.agent.providerSessionId,
+      request.onSession,
+      this.maxLineBytes,
+    );
+    let processing = Promise.resolve();
 
-        child.stdout.on('data', (chunk: Buffer | string) => {
-            if (parser.hasFailed()) return;
-            processing = processing.then(() => parser.accept(chunk)).catch((error) => parser.fail(error));
-        });
-        child.stderr.resume();
-        const closed = waitForChildClose(child);
-        try {
-            await request.onSpawn(identity);
-        } catch (error) {
-            child.kill();
-            throw error;
-        }
-        child.stdin.end(request.prompt);
-        const { code, signal } = await closed.catch(() => {
-            throw new CodexPrintError('Codex process failed to start or communicate.', 'CODEX_PROCESS');
-        });
-        await processing;
-        return parser.result({ code, signal });
+    child.stdout.on("data", (chunk: Buffer | string) => {
+      if (parser.hasFailed()) return;
+      processing = processing.then(() => parser.accept(chunk)).catch((error) => parser.fail(error));
+    });
+    child.stderr.resume();
+    const closed = waitForChildClose(child);
+    try {
+      await request.onSpawn(identity);
+    } catch (error) {
+      child.kill();
+      throw error;
     }
+    child.stdin.end(request.prompt);
+    const { code, signal } = await closed.catch(() => {
+      throw new CodexPrintError("Codex process failed to start or communicate.", "CODEX_PROCESS");
+    });
+    await processing;
+    return parser.result({ code, signal });
+  }
 
-    private verifyProcessIdentity(child: ChildProcessWithoutNullStreams): ProcessIdentity {
-        if (!child.pid) {
-            child.kill();
-            throw new CodexPrintError('Codex process did not provide a PID.', 'CODEX_PROCESS');
-        }
-        const identity = this.processInspector.getIdentity(child.pid);
-        if (!identity) {
-            child.kill();
-            throw new CodexPrintError('Cannot verify Codex process identity.', 'CODEX_PROCESS');
-        }
-        return identity;
+  private verifyProcessIdentity(child: ChildProcessWithoutNullStreams): ProcessIdentity {
+    if (!child.pid) {
+      child.kill();
+      throw new CodexPrintError("Codex process did not provide a PID.", "CODEX_PROCESS");
+    }
+    const identity = this.processInspector.getIdentity(child.pid);
+    if (!identity) {
+      child.kill();
+      throw new CodexPrintError("Cannot verify Codex process identity.", "CODEX_PROCESS");
     }
+    return identity;
+  }
 }
 
 function buildCodexExecArgs(agent: CodexDurableAgent): string[] {
-    return agent.providerSessionId === null
-        ? ['exec', '--json', '-']
-        : ['exec', 'resume', '--json', agent.providerSessionId, '-'];
+  return agent.providerSessionId === null
+    ? ["exec", "--json", "-"]
+    : ["exec", "resume", "--json", agent.providerSessionId, "-"];
 }

package/src/providers/codex/durable/CodexStreamParser.ts

@@ -1,104 +1,117 @@
-import { CodexPrintError } from '../../../durable/DurableAgent.js';
-import { isUuid, LineBuffer, type ChildCloseResult } from '../../../durable/utils.js';
-import type { CodexPrintRunResult } from './CodexPrintRunner.js';
+import { CodexPrintError } from "../../../durable/DurableAgent.js";
+import { isUuid, LineBuffer, type ChildCloseResult } from "../../../durable/utils.js";
+import type { CodexPrintRunResult } from "./CodexPrintRunner.js";
 
 export class CodexStreamParser {
-    private readonly lines: LineBuffer;
-    private sessionId: string | null = null;
-    private turnCompleted = false;
-    private readonly messages: string[] = [];
-    private protocolError: CodexPrintError | null = null;
+  private readonly lines: LineBuffer;
+  private sessionId: string | null = null;
+  private turnCompleted = false;
+  private readonly messages: string[] = [];
+  private protocolError: CodexPrintError | null = null;
 
-    constructor(
-        private readonly expectedSessionId: string | null,
-        private readonly onSession: (providerSessionId: string) => Promise<void>,
-        maxLineBytes: number,
-    ) {
-        this.lines = new LineBuffer(
-            maxLineBytes,
-            () => new CodexPrintError('Codex stream line exceeded the safety limit.', 'CODEX_PROTOCOL'),
-        );
-    }
+  constructor(
+    private readonly expectedSessionId: string | null,
+    private readonly onSession: (providerSessionId: string) => Promise<void>,
+    maxLineBytes: number,
+  ) {
+    this.lines = new LineBuffer(
+      maxLineBytes,
+      () => new CodexPrintError("Codex stream line exceeded the safety limit.", "CODEX_PROTOCOL"),
+    );
+  }
 
-    hasFailed(): boolean {
-        return this.protocolError !== null;
-    }
+  hasFailed(): boolean {
+    return this.protocolError !== null;
+  }
 
-    async accept(chunk: Buffer | string): Promise<void> {
-        for (const line of this.lines.accept(chunk)) {
-            await this.processLine(line);
-        }
+  async accept(chunk: Buffer | string): Promise<void> {
+    for (const line of this.lines.accept(chunk)) {
+      await this.processLine(line);
     }
+  }
 
-    fail(error: unknown): void {
-        this.protocolError = error instanceof CodexPrintError
-            ? error
-            : new CodexPrintError('Codex stream processing failed.', 'CODEX_PROTOCOL');
-    }
+  fail(error: unknown): void {
+    this.protocolError =
+      error instanceof CodexPrintError
+        ? error
+        : new CodexPrintError("Codex stream processing failed.", "CODEX_PROTOCOL");
+  }
 
-    result(close: ChildCloseResult): CodexPrintRunResult {
-        if (this.protocolError) throw this.protocolError;
-        this.lines.assertComplete(
-            () => new CodexPrintError('Codex stream ended with incomplete JSON.', 'CODEX_PROTOCOL'),
-        );
+  result(close: ChildCloseResult): CodexPrintRunResult {
+    if (this.protocolError) throw this.protocolError;
+    this.lines.assertComplete(
+      () => new CodexPrintError("Codex stream ended with incomplete JSON.", "CODEX_PROTOCOL"),
+    );
 
-        if (close.code !== 0) {
-            throw new CodexPrintError(`Codex print run failed${close.signal ? ` (${close.signal})` : '.'}`, 'CODEX_PROCESS');
-        }
-        if (this.sessionId === null) throw new CodexPrintError('Codex stream ended without a thread identity.', 'CODEX_PROTOCOL');
-        if (!this.turnCompleted) throw new CodexPrintError('Codex stream ended before turn completion.', 'CODEX_PROTOCOL');
-        if (this.messages.length === 0) throw new CodexPrintError('Codex stream ended without an assistant result.', 'CODEX_RESULT_MISSING');
-        return {
-            sessionId: this.sessionId,
-            result: this.messages.at(-1)!,
-            messages: this.messages,
-            exitCode: close.code,
-        };
+    if (close.code !== 0) {
+      throw new CodexPrintError(
+        `Codex print run failed${close.signal ? ` (${close.signal})` : "."}`,
+        "CODEX_PROCESS",
+      );
     }
+    if (this.sessionId === null)
+      throw new CodexPrintError("Codex stream ended without a thread identity.", "CODEX_PROTOCOL");
+    if (!this.turnCompleted)
+      throw new CodexPrintError("Codex stream ended before turn completion.", "CODEX_PROTOCOL");
+    if (this.messages.length === 0)
+      throw new CodexPrintError(
+        "Codex stream ended without an assistant result.",
+        "CODEX_RESULT_MISSING",
+      );
+    return {
+      sessionId: this.sessionId,
+      result: this.messages.at(-1)!,
+      messages: this.messages,
+      exitCode: close.code,
+    };
+  }
 
-    private async processLine(line: Buffer): Promise<void> {
-        if (this.protocolError || line.length === 0) return;
+  private async processLine(line: Buffer): Promise<void> {
+    if (this.protocolError || line.length === 0) return;
 
-        const event = this.parseEvent(line);
-        if (event.type === 'thread.started') {
-            await this.recordSession(event);
-        } else if (event.type === 'item.completed') {
-            this.recordAssistantMessage(event.item);
-        } else if (event.type === 'turn.completed') {
-            this.turnCompleted = true;
-        }
+    const event = this.parseEvent(line);
+    if (event.type === "thread.started") {
+      await this.recordSession(event);
+    } else if (event.type === "item.completed") {
+      this.recordAssistantMessage(event.item);
+    } else if (event.type === "turn.completed") {
+      this.turnCompleted = true;
     }
+  }
 
-    private parseEvent(line: Buffer): Record<string, unknown> {
-        let value: unknown;
-        try {
-            value = JSON.parse(line.toString('utf8'));
-        } catch {
-            throw new CodexPrintError('Codex emitted malformed stream JSON.', 'CODEX_PROTOCOL');
-        }
-        if (!value || typeof value !== 'object' || Array.isArray(value)) {
-            throw new CodexPrintError('Codex emitted a non-object stream message.', 'CODEX_PROTOCOL');
-        }
-        return value as Record<string, unknown>;
+  private parseEvent(line: Buffer): Record<string, unknown> {
+    let value: unknown;
+    try {
+      value = JSON.parse(line.toString("utf8"));
+    } catch {
+      throw new CodexPrintError("Codex emitted malformed stream JSON.", "CODEX_PROTOCOL");
     }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      throw new CodexPrintError("Codex emitted a non-object stream message.", "CODEX_PROTOCOL");
+    }
+    return value as Record<string, unknown>;
+  }
 
-    private async recordSession(event: Record<string, unknown>): Promise<void> {
-        const sessionId = String(event.thread_id ?? '');
-        if (this.sessionId !== null || !isUuid(sessionId)) {
-            throw new CodexPrintError('Codex emitted an invalid thread identity.', 'CODEX_PROTOCOL');
-        }
-        if (this.expectedSessionId !== null && this.expectedSessionId !== sessionId) {
-            throw new CodexPrintError('Codex returned a different session identity.', 'CODEX_SESSION_MISMATCH');
-        }
-        this.sessionId = sessionId;
-        await this.onSession(sessionId);
+  private async recordSession(event: Record<string, unknown>): Promise<void> {
+    const sessionId = String(event.thread_id ?? "");
+    if (this.sessionId !== null || !isUuid(sessionId)) {
+      throw new CodexPrintError("Codex emitted an invalid thread identity.", "CODEX_PROTOCOL");
+    }
+    if (this.expectedSessionId !== null && this.expectedSessionId !== sessionId) {
+      throw new CodexPrintError(
+        "Codex returned a different session identity.",
+        "CODEX_SESSION_MISMATCH",
+      );
     }
+    this.sessionId = sessionId;
+    await this.onSession(sessionId);
+  }
 
-    private recordAssistantMessage(item: unknown): void {
-        if (!item || typeof item !== 'object' || Array.isArray(item)) return;
-        const record = item as Record<string, unknown>;
-        if (record.type === 'agent_message' && typeof record.text === 'string' && record.text.trim()) {
-            this.messages.push(record.text);
-        }
+  private recordAssistantMessage(item: unknown): void {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return;
+    const record = item as Record<string, unknown>;
+    if (record.type === "agent_message" && typeof record.text === "string" && record.text.trim()) {
+      this.messages.push(record.text);
     }
+  }
 }

package/src/providers/pi/PiAdapter.ts

@@ -0,0 +1,183 @@
+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 { AgentRegistry } from "../../utils/AgentRegistry.js";
+import { PiAgentMapper } from "./PiAgentMapper.js";
+import { PiSessionLocator } from "./PiSessionLocator.js";
+import { PiSessionParser } from "./PiSessionParser.js";
+import { PiSessionTracker } from "./PiSessionTracker.js";
+
+interface MappedAgentResult {
+  agents: AgentInfo[];
+  fallback: ProcessInfo[];
+}
+
+interface SessionFileMatch {
+  process: ProcessInfo;
+  filePath: string;
+}
+
+export class PiAdapter implements AgentAdapter {
+  readonly type = "pi" as const;
+  readonly processNames = ["pi", "node"] as const;
+
+  private readonly piSessionsDir: string;
+  private readonly trackerPath: string;
+  private readonly registry: AgentRegistry;
+  private readonly parser: PiSessionParser;
+  private readonly mapper: PiAgentMapper;
+
+  constructor(registry: AgentRegistry = AgentRegistry.default()) {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    const piAgentDir = path.join(homeDir, ".pi", "agent");
+    this.piSessionsDir = path.join(piAgentDir, "sessions");
+    this.trackerPath = path.join(piAgentDir, "sessions.json");
+    this.registry = registry;
+    this.parser = new PiSessionParser();
+    this.mapper = new PiAgentMapper(this.parser);
+  }
+
+  canHandle(processInfo: ProcessInfo): boolean {
+    return this.isPiExecutable(processInfo.command);
+  }
+
+  async detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {
+    const processes = await this.getPiProcesses(context);
+    if (processes.length === 0) return [];
+
+    const cacheResult = this.mapRegistryCache(processes);
+    const trackerResult = this.mapTrackerMatches(cacheResult.fallback);
+    const locatorResult = this.createLocator().matchRunningProcesses(trackerResult.fallback);
+    const legacyResult = this.mapLegacyMatches(locatorResult.legacyMatches);
+    const unmatchedProcesses = this.findUnmatchedProcesses(
+      locatorResult.fallback,
+      legacyResult.agents,
+    );
+
+    return [
+      ...cacheResult.agents,
+      ...trackerResult.agents,
+      ...legacyResult.agents,
+      ...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 getPiProcesses(context?: AgentDetectionContext): Promise<ProcessInfo[]> {
+    const snapshot = context?.processes ?? (await captureProcessSnapshot(this.processNames));
+    const relevant = filterByProcessNames(snapshot, this.processNames);
+
+    const byPid = new Map<number, ProcessInfo>();
+    for (const processInfo of relevant) {
+      if (this.canHandle(processInfo)) byPid.set(processInfo.pid, processInfo);
+    }
+    return Array.from(byPid.values());
+  }
+
+  private createLocator(): PiSessionLocator {
+    return new PiSessionLocator({ sessionsDir: this.piSessionsDir }, this.parser);
+  }
+
+  private createTracker(): PiSessionTracker {
+    return new PiSessionTracker({
+      sessionsDir: this.piSessionsDir,
+      trackerPath: this.trackerPath,
+    });
+  }
+
+  private mapRegistryCache(processes: ProcessInfo[]): MappedAgentResult {
+    const matches: SessionFileMatch[] = [];
+    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;
+      }
+
+      matches.push({ process: processInfo, filePath: entry.sessionFilePath });
+    }
+
+    const mapped = this.mapSessionFileMatches(matches);
+    return { agents: mapped.agents, fallback: [...fallback, ...mapped.fallback] };
+  }
+
+  private mapTrackerMatches(processes: ProcessInfo[]): MappedAgentResult {
+    const { matches, fallback } = this.createTracker().match(processes);
+    const mapped = this.mapSessionFileMatches(matches);
+    return { agents: mapped.agents, fallback: [...fallback, ...mapped.fallback] };
+  }
+
+  private mapLegacyMatches(
+    matches: Array<{ process: ProcessInfo; session: { filePath: string } }>,
+  ): MappedAgentResult {
+    return this.mapSessionFileMatches(
+      matches.map((match) => ({ process: match.process, filePath: match.session.filePath })),
+    );
+  }
+
+  private mapSessionFileMatches(matches: SessionFileMatch[]): MappedAgentResult {
+    const agents: AgentInfo[] = [];
+    const fallback: ProcessInfo[] = [];
+
+    for (const match of matches) {
+      const session = this.parser.readSession(match.filePath, match.process.cwd);
+      if (session) {
+        agents.push(this.mapper.mapSessionToAgent(session, match.process, match.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));
+  }
+
+  private isPiExecutable(command: string): boolean {
+    for (const token of command.trim().split(/\s+/)) {
+      const base = executableBasename(token);
+      if (base === "pi" || base === "pi.exe" || base === "pi.js") return true;
+    }
+    return false;
+  }
+}

package/src/providers/pi/PiAgentMapper.ts

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