@ai-devkit/agent-manager 0.35.0 → 0.37.0

package/src/providers/codex/CodexSessionLocator.ts

@@ -1,279 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import type { ProcessInfo } from "../../adapters/AgentAdapter.js";
-import { matchProcessesToSessions, type MatchResult } from "../../utils/matching.js";
-import {
-  batchGetSessionFileBirthtimes,
-  isDirectory,
-  safeReadFile,
-  safeReaddir,
-  safeStat,
-  type SessionFile,
-} from "../../utils/session.js";
-import { CodexSessionParser, type CodexEventEntry } from "./CodexSessionParser.js";
-
-export interface CodexDirectMatch {
-  process: ProcessInfo;
-  sessionFile: SessionFile;
-}
-
-export interface CodexProcessSessionMatches {
-  direct: CodexDirectMatch[];
-  legacyMatches: MatchResult[];
-  fallback: ProcessInfo[];
-  contentCache: Map<string, string>;
-}
-
-export interface CodexDiscoveredSessions {
-  sessions: SessionFile[];
-  contentCache: Map<string, string>;
-}
-
-export interface CodexSessionLocatorOptions {
-  sessionsDir?: string;
-}
-
-const PROCESS_START_DAY_WINDOW_DAYS = 1;
-
-export class CodexSessionLocator {
-  private readonly sessionsDir: string;
-
-  constructor(
-    options: CodexSessionLocatorOptions = {},
-    private readonly parser: CodexSessionParser = new CodexSessionParser(),
-  ) {
-    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-    this.sessionsDir = options.sessionsDir ?? path.join(homeDir, ".codex", "sessions");
-  }
-
-  matchRunningProcesses(processes: ProcessInfo[]): CodexProcessSessionMatches {
-    const { direct, fallback } = this.tryResumeMatching(processes);
-    const { sessions, contentCache } = this.discoverLiveSessions(fallback);
-    const legacyMatches =
-      fallback.length > 0 && sessions.length > 0
-        ? matchProcessesToSessions(fallback, sessions)
-        : [];
-
-    return { direct, legacyMatches, fallback, contentCache };
-  }
-
-  tryResumeMatching(processes: ProcessInfo[]): {
-    direct: CodexDirectMatch[];
-    fallback: ProcessInfo[];
-  } {
-    const direct: CodexDirectMatch[] = [];
-    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 };
-  }
-
-  discoverLiveSessions(processes: ProcessInfo[]): CodexDiscoveredSessions {
-    const empty = { sessions: [], contentCache: new Map<string, string>() };
-    if (!fs.existsSync(this.sessionsDir)) return empty;
-
-    const dateDirs = this.getDateDirs(processes);
-    if (dateDirs.length === 0) return empty;
-
-    return this.discoverSessionFilesInDateDirs(dateDirs);
-  }
-
-  discoverSessionFilesInDateDirs(dateDirs: string[]): CodexDiscoveredSessions {
-    const files = batchGetSessionFileBirthtimes(dateDirs);
-    const contentCache = new Map<string, string>();
-
-    for (const file of files) {
-      try {
-        const content = fs.readFileSync(file.filePath, "utf-8");
-        contentCache.set(file.filePath, content);
-
-        const firstLine = content.split("\n")[0]?.trim();
-        if (firstLine) {
-          const parsed = JSON.parse(firstLine) as CodexEventEntry;
-          if (parsed.type === "session_meta") {
-            file.resolvedCwd = parsed.payload?.cwd || "";
-            const metaTimestampMs = this.parser.parseMetaTimestampMs(parsed.payload?.timestamp);
-            if (metaTimestampMs !== null) {
-              file.birthtimeMs = metaTimestampMs;
-            }
-          }
-        }
-      } catch {
-        // Skip unreadable files
-      }
-    }
-
-    return { sessions: files, contentCache };
-  }
-
-  discoverHistoricalSessionFiles(): string[] {
-    return this.collectAllSessionFiles();
-  }
-
-  findSessionFileById(sessionId: string): SessionFile | null {
-    for (const filePath of this.getCandidateSessionFiles(sessionId)) {
-      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;
-        const metaTimestampMs = this.parser.parseMetaTimestampMs(parsed.payload?.timestamp);
-
-        return {
-          sessionId,
-          filePath,
-          projectDir: path.dirname(filePath),
-          birthtimeMs: metaTimestampMs ?? stat.birthtimeMs,
-          resolvedCwd: parsed.payload?.cwd || "",
-        };
-      } catch {
-        continue;
-      }
-    }
-
-    return null;
-  }
-
-  collectAllSessionFiles(): string[] {
-    const out: string[] = [];
-
-    for (const yearEntry of safeReaddir(this.sessionsDir)) {
-      const yearDir = path.join(this.sessionsDir, yearEntry);
-      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)) {
-          const dayDir = path.join(monthDir, dayEntry);
-          if (!isDirectory(dayDir)) continue;
-
-          for (const fileEntry of safeReaddir(dayDir)) {
-            if (!fileEntry.endsWith(".jsonl")) continue;
-            out.push(path.join(dayDir, fileEntry));
-          }
-        }
-      }
-    }
-
-    return out;
-  }
-
-  private extractResumeSessionId(command: string): string | null {
-    const match = command.match(/(?:^|\s)resume\s+([0-9a-f-]{36})(?:\s|$)/i);
-    return match?.[1] ?? null;
-  }
-
-  private getCandidateSessionFiles(sessionId: string): string[] {
-    const sessionDate = this.tryParseUuidV7Date(sessionId);
-    if (!sessionDate) return this.collectAllSessionFiles();
-
-    return this.collectSessionFilesInDateDirs(
-      this.getDateDirsAroundDate(sessionDate, PROCESS_START_DAY_WINDOW_DAYS),
-    );
-  }
-
-  private getDateDirs(processes: ProcessInfo[]): string[] {
-    const dayKeys = new Set<string>();
-
-    for (const proc of processes) {
-      const startTime = proc.startTime || new Date();
-      for (
-        let offset = -PROCESS_START_DAY_WINDOW_DAYS;
-        offset <= PROCESS_START_DAY_WINDOW_DAYS;
-        offset++
-      ) {
-        const day = new Date(startTime.getTime());
-        day.setDate(day.getDate() + offset);
-        dayKeys.add(this.toSessionDayKey(day));
-      }
-    }
-
-    const dirs: string[] = [];
-    for (const dayKey of dayKeys) {
-      const dayDir = path.join(this.sessionsDir, dayKey);
-      try {
-        if (fs.statSync(dayDir).isDirectory()) {
-          dirs.push(dayDir);
-        }
-      } catch {
-        continue;
-      }
-    }
-
-    return dirs;
-  }
-
-  private getDateDirsAroundDate(date: Date, windowDays: number): string[] {
-    const dirs: string[] = [];
-
-    for (let offset = -windowDays; offset <= windowDays; offset++) {
-      const day = new Date(date.getTime());
-      day.setDate(day.getDate() + offset);
-      const dayDir = path.join(this.sessionsDir, this.toSessionDayKey(day));
-      if (isDirectory(dayDir)) {
-        dirs.push(dayDir);
-      }
-    }
-
-    return dirs;
-  }
-
-  private toSessionDayKey(date: Date): string {
-    const yyyy = String(date.getFullYear()).padStart(4, "0");
-    const mm = String(date.getMonth() + 1).padStart(2, "0");
-    const dd = String(date.getDate()).padStart(2, "0");
-    return path.join(yyyy, mm, dd);
-  }
-
-  private tryParseUuidV7Date(sessionId: string): Date | null {
-    const match = sessionId.match(
-      /^([0-9a-f]{8})-([0-9a-f]{4})-7[0-9a-f]{3}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
-    );
-    if (!match) return null;
-
-    const timestampMs = Number.parseInt(`${match[1]}${match[2]}`, 16);
-    if (!Number.isSafeInteger(timestampMs) || timestampMs <= 0) return null;
-
-    const date = new Date(timestampMs);
-    return Number.isNaN(date.getTime()) ? null : date;
-  }
-
-  private collectSessionFilesInDateDirs(dateDirs: string[]): string[] {
-    const out: string[] = [];
-
-    for (const dayDir of dateDirs) {
-      for (const fileEntry of safeReaddir(dayDir)) {
-        if (!fileEntry.endsWith(".jsonl")) continue;
-        out.push(path.join(dayDir, fileEntry));
-      }
-    }
-
-    return out;
-  }
-}

package/src/providers/copilot/CopilotSessionLocator.ts

@@ -1,63 +0,0 @@
-import * as path from "path";
-import { isDirectory, isSafePathSegment, safeReaddir } from "../../utils/session.js";
-
-export interface CopilotLock {
-  sessionDir: string;
-  sessionId: string;
-  pid: number;
-}
-
-export interface CopilotSessionDir {
-  sessionDir: string;
-  sessionId: string;
-}
-
-export interface CopilotSessionLocatorOptions {
-  sessionStateDir?: string;
-}
-
-export class CopilotSessionLocator {
-  private readonly sessionStateDir: string;
-
-  constructor(options: CopilotSessionLocatorOptions = {}) {
-    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-    this.sessionStateDir =
-      options.sessionStateDir ?? path.join(homeDir, ".copilot", "session-state");
-  }
-
-  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;
-  }
-
-  findSessionDirById(sessionId: string): CopilotSessionDir | null {
-    if (!isSafePathSegment(sessionId)) return null;
-    const sessionDir = path.join(this.sessionStateDir, sessionId);
-    return isDirectory(sessionDir) ? { sessionDir, sessionId } : null;
-  }
-
-  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;
-  }
-}

package/src/providers/copilot/CopilotSessionParser.ts

@@ -1,289 +0,0 @@
-import * as path from "path";
-import type { ConversationMessage } from "../../adapters/AgentAdapter.js";
-import { AgentStatus } from "../../adapters/AgentAdapter.js";
-import { safeReadFile, 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;
-}
-
-export interface CopilotSession {
-  sessionId: string;
-  projectPath: string;
-  summary: string;
-  sessionStart: Date;
-  lastActive: Date;
-  lastEventType?: string;
-  firstUserMessage: string;
-  eventsFilePath: string;
-}
-
-interface CopilotEventSummary {
-  sessionId: string;
-  projectPath: string;
-  sessionStart: Date;
-  lastActive: Date;
-  firstUserMessage: string;
-  lastText: string;
-  lastEventType?: string;
-}
-
-const IDLE_THRESHOLD_MINUTES = 5;
-const VERBOSE_SYSTEM_EVENTS = new Set([
-  "system.message",
-  "session.info",
-  "session.warning",
-  "tool.execution_start",
-  "tool.execution_complete",
-  "function",
-  "abort",
-]);
-const WAITING_EVENTS = new Set([
-  "assistant.message",
-  "assistant.turn_end",
-  "session.shutdown",
-  "abort",
-]);
-
-export class CopilotSessionParser {
-  readSessionDir(sessionDir: string, fallbackSessionId: string): CopilotSession | null {
-    const eventsFilePath = path.join(sessionDir, "events.jsonl");
-    const workspace = this.readWorkspaceMetadata(path.join(sessionDir, "workspace.yaml"));
-    const entries = this.readEventEntries(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.buildSessionFromEntries(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,
-    };
-  }
-
-  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;
-  }
-
-  determineStatus(session: CopilotSession): AgentStatus {
-    const diffMs = Date.now() - session.lastActive.getTime();
-    const diffMinutes = diffMs / 60000;
-    if (diffMinutes > IDLE_THRESHOLD_MINUTES) {
-      return AgentStatus.IDLE;
-    }
-
-    if (session.lastEventType !== undefined && WAITING_EVENTS.has(session.lastEventType)) {
-      return AgentStatus.WAITING;
-    }
-
-    return AgentStatus.RUNNING;
-  }
-
-  private readEventEntries(eventsFilePath: string): CopilotEventEntry[] {
-    const content = safeReadFile(eventsFilePath);
-    return content === undefined ? [] : this.parseEventLines(content);
-  }
-
-  private buildSessionFromEntries(
-    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 readWorkspaceMetadata(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 && 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 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)}...`;
-  }
-}