@ai-devkit/agent-manager 0.32.0 → 0.33.0

package/src/providers/codex/CodexSessionParser.ts

@@ -0,0 +1,385 @@
+import * as fs from "fs";
+import type { ConversationMessage, SessionSummary } from "../../adapters/AgentAdapter.js";
+import { AgentStatus } from "../../adapters/AgentAdapter.js";
+import { safeReadFile, safeStat } from "../../utils/session.js";
+
+export interface CodexEventEntry {
+  timestamp?: string;
+  type?: string;
+  payload?: {
+    type?: string;
+    message?: string;
+    id?: string;
+    cwd?: string;
+    timestamp?: string;
+    role?: string;
+    content?: CodexContent[];
+    item?: CodexItem;
+    turn_id?: string;
+    internal_chat_message_metadata_passthrough?: {
+      turn_id?: string;
+    };
+  };
+}
+
+export interface CodexContent {
+  type?: string;
+  text?: string;
+}
+
+export interface CodexItem {
+  type?: string;
+  content?: string | CodexContent[];
+}
+
+export interface CodexSession {
+  sessionId: string;
+  projectPath: string;
+  summary: string;
+  sessionStart: Date;
+  lastActive: Date;
+  lastPayloadType?: string;
+}
+
+const IDLE_THRESHOLD_MINUTES = 5;
+
+export class CodexSessionParser {
+  readSession(filePath: string, cachedContent?: string): CodexSession | null {
+    let content: string;
+    if (cachedContent !== undefined) {
+      content = cachedContent;
+    } else {
+      try {
+        content = fs.readFileSync(filePath, "utf-8");
+      } catch {
+        return null;
+      }
+    }
+
+    const allLines = content.trim().split("\n");
+    if (!allLines[0]) return null;
+
+    let metaEntry: CodexEventEntry;
+    try {
+      metaEntry = JSON.parse(allLines[0]);
+    } catch {
+      return null;
+    }
+
+    if (metaEntry.type !== "session_meta" || !metaEntry.payload?.id) {
+      return null;
+    }
+
+    const entries: CodexEventEntry[] = [];
+    for (const line of allLines) {
+      try {
+        entries.push(JSON.parse(line));
+      } catch {
+        continue;
+      }
+    }
+
+    const lastEntry = this.findLastEventEntry(entries);
+    const lastPayloadType = lastEntry ? this.normalizedPayloadType(lastEntry) : undefined;
+
+    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,
+    };
+  }
+
+  determineStatus(session: CodexSession): AgentStatus {
+    const diffMs = Date.now() - session.lastActive.getTime();
+    const diffMinutes = diffMs / 60000;
+
+    if (diffMinutes > IDLE_THRESHOLD_MINUTES) {
+      return AgentStatus.IDLE;
+    }
+
+    if (
+      session.lastPayloadType === "agent_message" ||
+      session.lastPayloadType === "task_complete" ||
+      session.lastPayloadType === "turn_aborted"
+    ) {
+      return AgentStatus.WAITING;
+    }
+
+    return AgentStatus.RUNNING;
+  }
+
+  getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {
+    const verbose = options?.verbose ?? false;
+
+    const content = safeReadFile(sessionFilePath);
+    if (content === undefined) return [];
+
+    const lines = content.trim().split("\n");
+    const entries: CodexEventEntry[] = [];
+    const messages: ConversationMessage[] = [];
+
+    for (const line of lines) {
+      try {
+        entries.push(JSON.parse(line));
+      } catch {
+        continue;
+      }
+    }
+
+    const responseItemMirrorKeys = new Set<string>();
+    for (const entry of entries) {
+      if (entry.type !== "response_item") continue;
+
+      const message = this.toConversationMessage(entry, verbose);
+      const mirrorKey = message ? this.mirroredMessageKey(entry, message) : null;
+      if (mirrorKey) responseItemMirrorKeys.add(mirrorKey);
+    }
+
+    for (const entry of entries) {
+      const message = this.toConversationMessage(entry, verbose);
+      if (!message) continue;
+
+      const mirrorKey = this.mirroredMessageKey(entry, message);
+      if (entry.type === "event_msg" && mirrorKey && responseItemMirrorKeys.has(mirrorKey)) {
+        continue;
+      }
+
+      messages.push(message);
+    }
+
+    return messages;
+  }
+
+  fileToSessionSummary(filePath: string): SessionSummary | null {
+    const content = safeReadFile(filePath);
+    if (content === undefined) return null;
+
+    const allLines = content.trim().split("\n");
+    if (!allLines[0]) return null;
+
+    let metaEntry: CodexEventEntry;
+    try {
+      metaEntry = JSON.parse(allLines[0]);
+    } catch {
+      return null;
+    }
+
+    if (metaEntry.type !== "session_meta" || !metaEntry.payload?.id) {
+      return null;
+    }
+
+    let firstUserMessage = "";
+    let lastTimestamp: Date | null = null;
+
+    for (let i = 1; i < allLines.length; i++) {
+      let entry: CodexEventEntry;
+      try {
+        entry = JSON.parse(allLines[i]);
+      } catch {
+        continue;
+      }
+
+      const ts = this.parseTimestamp(entry.timestamp);
+      if (ts) lastTimestamp = ts;
+
+      if (!firstUserMessage) {
+        const message = this.toConversationMessage(entry, false);
+        const content = message?.content.trim() ?? "";
+        if (
+          message?.role === "user" &&
+          content.length > 0 &&
+          !this.isSyntheticUserMessage(content)
+        ) {
+          firstUserMessage = content;
+        }
+      }
+    }
+
+    const stat = safeStat(filePath);
+
+    const startedAt =
+      this.parseTimestamp(metaEntry.payload.timestamp) ||
+      lastTimestamp ||
+      stat?.birthtime ||
+      stat?.mtime ||
+      new Date();
+    const lastActive = lastTimestamp || startedAt;
+
+    return {
+      type: "codex",
+      sessionId: metaEntry.payload.id,
+      cwd: metaEntry.payload.cwd || "",
+      firstUserMessage,
+      lastActive,
+      startedAt,
+      sessionFilePath: filePath,
+    };
+  }
+
+  parseTimestamp(value?: string): Date | null {
+    if (!value) return null;
+    const timestamp = new Date(value);
+    return Number.isNaN(timestamp.getTime()) ? null : timestamp;
+  }
+
+  parseMetaTimestampMs(value?: string): number | null {
+    if (typeof value !== "string") return null;
+
+    const timestamp = this.parseTimestamp(value);
+    if (!timestamp) return null;
+
+    const timestampMs = timestamp.getTime();
+    return Number.isFinite(timestampMs) ? timestampMs : null;
+  }
+
+  private findLastEventEntry(entries: CodexEventEntry[]): CodexEventEntry | undefined {
+    for (let i = entries.length - 1; i >= 0; i--) {
+      const entry = entries[i];
+      if (entry && typeof entry.type === "string") {
+        return entry;
+      }
+    }
+    return undefined;
+  }
+
+  private extractSummary(entries: CodexEventEntry[]): string {
+    for (let i = entries.length - 1; i >= 0; i--) {
+      const message = this.extractEntryText(entries[i]);
+      if (message) return this.truncate(message, 120);
+    }
+
+    return "Codex session active";
+  }
+
+  private normalizedPayloadType(entry: CodexEventEntry): string | undefined {
+    const payloadType = entry.payload?.type;
+
+    if (entry.type === "response_item" && payloadType === "message") {
+      if (entry.payload?.role === "assistant") return "agent_message";
+      if (entry.payload?.role === "user") return "user_message";
+      return payloadType;
+    }
+
+    if (entry.type === "event_msg" && payloadType === "item_completed") {
+      const itemType = entry.payload?.item?.type;
+      if (itemType === "AgentMessage") return "agent_message";
+      if (itemType === "UserMessage") return "user_message";
+      return itemType ?? payloadType;
+    }
+
+    return payloadType;
+  }
+
+  private extractEntryText(entry: CodexEventEntry | undefined): string {
+    if (!entry) return "";
+
+    const legacyMessage = entry.payload?.message;
+    if (typeof legacyMessage === "string" && legacyMessage.trim().length > 0) {
+      return legacyMessage.trim();
+    }
+
+    const conversationMessage = this.toConversationMessage(entry, false);
+    return conversationMessage?.content.trim() ?? "";
+  }
+
+  private truncate(value: string, maxLength: number): string {
+    if (value.length <= maxLength) return value;
+    return `${value.slice(0, maxLength - 3)}...`;
+  }
+
+  private toConversationMessage(
+    entry: CodexEventEntry,
+    verbose: boolean,
+  ): ConversationMessage | null {
+    if (entry.type === "session_meta") return null;
+
+    const payloadType = entry.payload?.type;
+    if (entry.type === "response_item" && payloadType === "message") {
+      const role = this.mapCodexRole(entry.payload?.role, verbose);
+      const text = this.extractContentText(entry.payload?.content);
+      if (!role || !text) return null;
+
+      return { role, content: text, timestamp: entry.timestamp };
+    }
+
+    if (entry.type === "event_msg" && payloadType === "item_completed") {
+      const item = entry.payload?.item;
+      const role = this.mapCodexItemRole(item?.type, verbose);
+      const text = this.extractContentText(item?.content);
+      if (!role || !text) return null;
+
+      return { role, content: text, timestamp: entry.timestamp };
+    }
+
+    if (!payloadType) return null;
+
+    let role: ConversationMessage["role"];
+    if (payloadType === "user_message") {
+      role = "user";
+    } else if (payloadType === "agent_message" || payloadType === "task_complete") {
+      role = "assistant";
+    } else if (verbose) {
+      role = "system";
+    } else {
+      return null;
+    }
+
+    const text = entry.payload?.message?.trim();
+    if (!text) return null;
+
+    return { role, content: text, timestamp: entry.timestamp };
+  }
+
+  private mapCodexRole(
+    role: string | undefined,
+    verbose: boolean,
+  ): ConversationMessage["role"] | null {
+    if (role === "user") return "user";
+    if (role === "assistant") return "assistant";
+    return verbose ? "system" : null;
+  }
+
+  private mapCodexItemRole(
+    itemType: string | undefined,
+    verbose: boolean,
+  ): ConversationMessage["role"] | null {
+    if (itemType === "AgentMessage") return "assistant";
+    if (itemType === "UserMessage") return "user";
+    return verbose ? "system" : null;
+  }
+
+  private mirroredMessageKey(entry: CodexEventEntry, message: ConversationMessage): string | null {
+    const turnId =
+      entry.payload?.turn_id || entry.payload?.internal_chat_message_metadata_passthrough?.turn_id;
+
+    if (!turnId) return null;
+    return `${turnId}\0${message.role}\0${message.content}`;
+  }
+
+  private extractContentText(content: string | CodexContent[] | undefined): string {
+    if (typeof content === "string") return content.trim();
+    if (!Array.isArray(content)) return "";
+
+    return content
+      .map((part) => part.text)
+      .filter((text): text is string => typeof text === "string" && text.trim().length > 0)
+      .map((text) => text.trim())
+      .join("\n")
+      .trim();
+  }
+
+  private isSyntheticUserMessage(content: string): boolean {
+    return (
+      content.startsWith("<environment_context>") && content.includes("</environment_context>")
+    );
+  }
+}

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

@@ -1,7 +1,7 @@
-import { execFile } from 'child_process';
-import { promisify } from 'util';
-import { CodexPrintError } from '../../../durable/DurableAgent.js';
-import { sanitizeText } from '../../../durable/utils.js';
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { CodexPrintError } from "../../../durable/DurableAgent.js";
+import { sanitizeText } from "../../../durable/utils.js";
 
 type ExecResult = { stdout: string; stderr: string };
 type Exec = (file: string, args: string[]) => Promise<ExecResult>;
@@ -9,52 +9,60 @@ type Exec = (file: string, args: string[]) => Promise<ExecResult>;
 const execFileAsync = promisify(execFile);
 
 export interface CodexCliProbeOptions {
-    executable?: string;
-    exec?: Exec;
+  executable?: string;
+  exec?: Exec;
 }
 
 export class CodexCliProbe {
-    private readonly executable: string;
-    private readonly exec: Exec;
+  private readonly executable: string;
+  private readonly exec: Exec;
 
-    constructor(options: CodexCliProbeOptions = {}) {
-        this.executable = options.executable ?? 'codex';
-        this.exec = options.exec ?? (async (file, args) => {
-            const result = await execFileAsync(file, args, { encoding: 'utf8', maxBuffer: 1024 * 1024 });
-            return { stdout: result.stdout, stderr: result.stderr };
+  constructor(options: CodexCliProbeOptions = {}) {
+    this.executable = options.executable ?? "codex";
+    this.exec =
+      options.exec ??
+      (async (file, args) => {
+        const result = await execFileAsync(file, args, {
+          encoding: "utf8",
+          maxBuffer: 1024 * 1024,
         });
-    }
+        return { stdout: result.stdout, stderr: result.stderr };
+      });
+  }
 
-    async validate(): Promise<{ executable: string; version: string }> {
-        try {
-            const version = await this.exec(this.executable, ['--version']);
-            const execHelp = await this.exec(this.executable, ['exec', '--help']);
-            const resumeHelp = await this.exec(this.executable, ['exec', 'resume', '--help']);
-            const missing = [
-                !execHelp.stdout.includes('exec') && 'exec',
-                !execHelp.stdout.includes('--json') && '--json',
-                !hasStdinDash(execHelp.stdout) && 'stdin -',
-                !resumeHelp.stdout.includes('resume') && 'resume',
-                !resumeHelp.stdout.includes('--json') && 'resume --json',
-                !hasStdinDash(resumeHelp.stdout) && 'resume stdin -',
-            ].filter((value): value is string => typeof value === 'string');
-            if (missing.length > 0) {
-                throw new CodexPrintError(
-                    `Codex CLI does not support required print-mode capabilities: ${missing.join(', ')}.`,
-                    'CODEX_CLI_UNSUPPORTED',
-                );
-            }
-            return { executable: this.executable, version: sanitizeText(version.stdout, 256) || 'unknown' };
-        } catch (error) {
-            if (error instanceof CodexPrintError) throw error;
-            throw new CodexPrintError(
-                `Codex CLI validation failed: ${sanitizeText((error as Error).message, 512)}`,
-                'CODEX_CLI_UNAVAILABLE',
-            );
-        }
+  async validate(): Promise<{ executable: string; version: string }> {
+    try {
+      const version = await this.exec(this.executable, ["--version"]);
+      const execHelp = await this.exec(this.executable, ["exec", "--help"]);
+      const resumeHelp = await this.exec(this.executable, ["exec", "resume", "--help"]);
+      const missing = [
+        !execHelp.stdout.includes("exec") && "exec",
+        !execHelp.stdout.includes("--json") && "--json",
+        !hasStdinDash(execHelp.stdout) && "stdin -",
+        !resumeHelp.stdout.includes("resume") && "resume",
+        !resumeHelp.stdout.includes("--json") && "resume --json",
+        !hasStdinDash(resumeHelp.stdout) && "resume stdin -",
+      ].filter((value): value is string => typeof value === "string");
+      if (missing.length > 0) {
+        throw new CodexPrintError(
+          `Codex CLI does not support required print-mode capabilities: ${missing.join(", ")}.`,
+          "CODEX_CLI_UNSUPPORTED",
+        );
+      }
+      return {
+        executable: this.executable,
+        version: sanitizeText(version.stdout, 256) || "unknown",
+      };
+    } catch (error) {
+      if (error instanceof CodexPrintError) throw error;
+      throw new CodexPrintError(
+        `Codex CLI validation failed: ${sanitizeText((error as Error).message, 512)}`,
+        "CODEX_CLI_UNAVAILABLE",
+      );
     }
+  }
 }
 
 function hasStdinDash(help: string): boolean {
-    return /(?:^|\s)-(?:\s|$)/m.test(help);
+  return /(?:^|\s)-(?:\s|$)/m.test(help);
 }

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

@@ -1,65 +1,79 @@
-import type { DurableAgent, ProcessIdentity } from '../../../durable/DurableAgent.js';
-import { CodexPrintError } from '../../../durable/DurableAgent.js';
-import { CodexCliProbe } from './CodexCliProbe.js';
-import { CodexPrintRunner, type CodexPrintRunResult } from './CodexPrintRunner.js';
-import { DurableAgentRepository, type CreateDurableAgentInput } from '../../../durable/DurableAgentRepository.js';
-import { runDurableAgent, type DurableRunRepository } from '../../../durable/run.js';
+import type { DurableAgent, ProcessIdentity } from "../../../durable/DurableAgent.js";
+import { CodexPrintError } from "../../../durable/DurableAgent.js";
+import { CodexCliProbe } from "./CodexCliProbe.js";
+import { CodexPrintRunner, type CodexPrintRunResult } from "./CodexPrintRunner.js";
+import {
+  DurableAgentRepository,
+  type CreateDurableAgentInput,
+} from "../../../durable/DurableAgentRepository.js";
+import { runDurableAgent, type DurableRunRepository } from "../../../durable/run.js";
 
 interface RepositoryLike extends DurableRunRepository {
-    create(input: CreateDurableAgentInput): Promise<DurableAgent>;
-    list(): Promise<DurableAgent[]>;
-    recordProviderProcess(id: string, token: string, identity: ProcessIdentity): Promise<void>;
-    bindProviderSession(id: string, token: string, providerSessionId: string): Promise<DurableAgent>;
+  create(input: CreateDurableAgentInput): Promise<DurableAgent>;
+  list(): Promise<DurableAgent[]>;
+  recordProviderProcess(id: string, token: string, identity: ProcessIdentity): Promise<void>;
+  bindProviderSession(id: string, token: string, providerSessionId: string): Promise<DurableAgent>;
 }
 
-interface ProbeLike { validate(): Promise<{ executable: string; version: string }> }
-interface RunnerLike { run(request: Parameters<CodexPrintRunner['run']>[0]): Promise<CodexPrintRunResult> }
+interface ProbeLike {
+  validate(): Promise<{ executable: string; version: string }>;
+}
+interface RunnerLike {
+  run(request: Parameters<CodexPrintRunner["run"]>[0]): Promise<CodexPrintRunResult>;
+}
 
 export interface CodexPrintAgentServiceOptions {
-    repository?: RepositoryLike;
-    probe?: ProbeLike;
-    runner?: RunnerLike;
-    executable?: string;
+  repository?: RepositoryLike;
+  probe?: ProbeLike;
+  runner?: RunnerLike;
+  executable?: string;
 }
 
 export interface CodexPrintSendResult extends CodexPrintRunResult {
-    agentId: string;
-    agentName: string;
+  agentId: string;
+  agentName: string;
 }
 
 export class CodexPrintAgentService {
-    readonly repository: RepositoryLike;
-    private readonly probe: ProbeLike;
-    private readonly runner: RunnerLike;
-    private readonly executable?: string;
+  readonly repository: RepositoryLike;
+  private readonly probe: ProbeLike;
+  private readonly runner: RunnerLike;
+  private readonly executable?: string;
 
-    constructor(options: CodexPrintAgentServiceOptions = {}) {
-        this.repository = options.repository ?? new DurableAgentRepository();
-        this.probe = options.probe ?? new CodexCliProbe();
-        this.runner = options.runner ?? new CodexPrintRunner();
-        this.executable = options.executable;
-    }
+  constructor(options: CodexPrintAgentServiceOptions = {}) {
+    this.repository = options.repository ?? new DurableAgentRepository();
+    this.probe = options.probe ?? new CodexCliProbe();
+    this.runner = options.runner ?? new CodexPrintRunner();
+    this.executable = options.executable;
+  }
 
-    async create(input: Omit<CreateDurableAgentInput, 'provider'>): Promise<DurableAgent> {
-        await this.probe.validate();
-        return this.repository.create({ ...input, provider: 'codex' });
-    }
+  async create(input: Omit<CreateDurableAgentInput, "provider">): Promise<DurableAgent> {
+    await this.probe.validate();
+    return this.repository.create({ ...input, provider: "codex" });
+  }
 
-    async send(reference: string, prompt: string): Promise<CodexPrintSendResult> {
-        const completed = await runDurableAgent({
-            reference, provider: 'codex', repository: this.repository,
-            ambiguousError: () => new CodexPrintError('Multiple print agents match.', 'CODEX_UNSUPPORTED'),
-            providerError: () => new CodexPrintError('Print agent provider is not Codex.', 'CODEX_UNSUPPORTED'),
-            execute: (agent, token) => this.runner.run({
-                agent,
-                prompt,
-                executable: this.executable,
-                onSpawn: (identity) => this.repository.recordProviderProcess(agent.id, token, identity),
-                onSession: async (sessionId) => { await this.repository.bindProviderSession(agent.id, token, sessionId); },
-            }),
-            isSessionMismatch: (error) => error instanceof CodexPrintError
-                && error.code === 'CODEX_SESSION_MISMATCH',
-        });
-        return { ...completed.result, agentId: completed.agent.id, agentName: completed.agent.name };
-    }
+  async send(reference: string, prompt: string): Promise<CodexPrintSendResult> {
+    const completed = await runDurableAgent({
+      reference,
+      provider: "codex",
+      repository: this.repository,
+      ambiguousError: () =>
+        new CodexPrintError("Multiple print agents match.", "CODEX_UNSUPPORTED"),
+      providerError: () =>
+        new CodexPrintError("Print agent provider is not Codex.", "CODEX_UNSUPPORTED"),
+      execute: (agent, token) =>
+        this.runner.run({
+          agent,
+          prompt,
+          executable: this.executable,
+          onSpawn: (identity) => this.repository.recordProviderProcess(agent.id, token, identity),
+          onSession: async (sessionId) => {
+            await this.repository.bindProviderSession(agent.id, token, sessionId);
+          },
+        }),
+      isSessionMismatch: (error) =>
+        error instanceof CodexPrintError && error.code === "CODEX_SESSION_MISMATCH",
+    });
+    return { ...completed.result, agentId: completed.agent.id, agentName: completed.agent.name };
+  }
 }