@ai-devkit/agent-manager 0.36.0 → 0.38.0

package/src/providers/grok/GrokSessionLocator.ts

@@ -1,179 +0,0 @@
-import * as path from "path";
-import type { ProcessInfo } from "../../adapters/AgentAdapter.js";
-import {
-  isDirectory,
-  isSafePathSegment,
-  safeReadFile,
-  safeReaddir,
-  safeStat,
-} from "../../utils/session.js";
-import { CHAT_HISTORY_FILE } from "./GrokSessionParser.js";
-
-const ACTIVE_SESSIONS_FILE = "active_sessions.json";
-const CWD_FILE = ".cwd";
-
-/** One entry of ~/.grok/active_sessions.json. */
-interface ActiveSessionEntry {
-  pid?: number;
-  cwd?: string;
-  opened_at?: number | string;
-}
-
-/** A live Grok process paired with its resolved cwd and (if any) session dir. */
-export interface GrokProcessMatch {
-  process: ProcessInfo;
-  cwd: string;
-  sessionDir: string | null;
-}
-
-/** A historical session dir plus the cwd decoded from its group dir. */
-export interface GrokSessionDir {
-  sessionDir: string;
-  defaultCwd: string;
-}
-
-export interface GrokSessionLocatorOptions {
-  /** Overrides the ~/.grok base directory (defaults to GROK_HOME or ~/.grok). */
-  baseDir?: string;
-}
-
-export class GrokSessionLocator {
-  private readonly baseDir: string;
-  private readonly sessionsDir: string;
-
-  constructor(options: GrokSessionLocatorOptions = {}) {
-    // GROK_HOME overrides the ~/.grok base directory; sessions live under
-    // <base>/sessions/ and the active-session registry at
-    // <base>/active_sessions.json.
-    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-    this.baseDir = options.baseDir ?? (process.env.GROK_HOME || path.join(homeDir, ".grok"));
-    this.sessionsDir = path.join(this.baseDir, "sessions");
-  }
-
-  /**
-   * Pair live Grok processes with their session dirs.
-   *
-   * active_sessions.json is the authoritative pid -> cwd map for live
-   * sessions; the lsof-derived process cwd is only a fallback. The most
-   * recently active session under that cwd's group dir is picked.
-   */
-  matchRunningProcesses(processes: ProcessInfo[]): GrokProcessMatch[] {
-    const pidToCwd = this.readActiveSessions();
-    return processes.map((proc) => {
-      const cwd = pidToCwd.get(proc.pid) || proc.cwd || "";
-      return { process: proc, cwd, sessionDir: cwd ? this.latestSessionDir(cwd) : null };
-    });
-  }
-
-  /** Every session dir under ~/.grok/sessions/, across all project groups. */
-  discoverHistoricalSessionDirs(): GrokSessionDir[] {
-    const results: GrokSessionDir[] = [];
-    for (const { groupDir, defaultCwd } of this.listGroups()) {
-      for (const sessionDir of this.listSessionDirs(groupDir)) {
-        results.push({ sessionDir, defaultCwd });
-      }
-    }
-    return results;
-  }
-
-  /** Session dirs named exactly `sessionId`, across all project groups. */
-  findHistoricalSessionDirsById(sessionId: string): GrokSessionDir[] {
-    if (!isSafePathSegment(sessionId)) return [];
-
-    const results: GrokSessionDir[] = [];
-    for (const { groupDir, defaultCwd } of this.listGroups()) {
-      const sessionDir = path.join(groupDir, sessionId);
-      if (isDirectory(sessionDir)) {
-        results.push({ sessionDir, defaultCwd });
-      }
-    }
-    return results;
-  }
-
-  /**
-   * Read ~/.grok/active_sessions.json into a pid -> cwd map. Grok writes one
-   * { pid, cwd, opened_at } entry per running session and removes it on exit,
-   * so this is the reliable way to learn a live process's working directory.
-   */
-  private readActiveSessions(): Map<number, string> {
-    const map = new Map<number, string>();
-    const content = safeReadFile(path.join(this.baseDir, ACTIVE_SESSIONS_FILE));
-    if (content === undefined) return map;
-
-    let entries: unknown;
-    try {
-      entries = JSON.parse(content);
-    } catch {
-      return map;
-    }
-    if (!Array.isArray(entries)) return map;
-
-    for (const entry of entries as ActiveSessionEntry[]) {
-      if (typeof entry?.pid === "number" && typeof entry?.cwd === "string" && entry.cwd) {
-        map.set(entry.pid, entry.cwd);
-      }
-    }
-    return map;
-  }
-
-  /**
-   * Return the most recently active session subdirectory for a cwd, i.e. the
-   * ~/.grok/sessions/<encodeURIComponent(cwd)>/<id>/ whose chat_history.jsonl
-   * was written last. Returns null when the group dir or any transcript is
-   * missing.
-   */
-  private latestSessionDir(cwd: string): string | null {
-    const groupDir = path.join(this.sessionsDir, encodeURIComponent(cwd));
-    if (!isDirectory(groupDir)) return null;
-
-    let best: { dir: string; mtimeMs: number } | null = null;
-    for (const sessionDir of this.listSessionDirs(groupDir)) {
-      const stat = safeStat(path.join(sessionDir, CHAT_HISTORY_FILE));
-      if (!stat) continue;
-      if (!best || stat.mtimeMs > best.mtimeMs) {
-        best = { dir: sessionDir, mtimeMs: stat.mtimeMs };
-      }
-    }
-    return best?.dir ?? null;
-  }
-
-  private listGroups(): Array<{ groupDir: string; defaultCwd: string }> {
-    if (!isDirectory(this.sessionsDir)) return [];
-
-    const groups: Array<{ groupDir: string; defaultCwd: string }> = [];
-    for (const groupName of safeReaddir(this.sessionsDir)) {
-      const groupDir = path.join(this.sessionsDir, groupName);
-      if (!isDirectory(groupDir)) continue;
-      groups.push({ groupDir, defaultCwd: this.decodeGroupCwd(groupName, groupDir) });
-    }
-    return groups;
-  }
-
-  /**
-   * Full paths of the session subdirectories directly under a group dir,
-   * skipping any non-directory entries (e.g. prompt_history.jsonl).
-   */
-  private listSessionDirs(groupDir: string): string[] {
-    return safeReaddir(groupDir)
-      .map((sessionId) => path.join(groupDir, sessionId))
-      .filter((sessionDir) => isDirectory(sessionDir));
-  }
-
-  /**
-   * Resolve the working directory a session group dir was created for.
-   *
-   * The common case is `decodeURIComponent(<group-name>)`. For paths whose
-   * encoded form exceeds the filesystem limit Grok uses a slug+hash and records
-   * the original path in a `.cwd` file inside the group — prefer that when
-   * present.
-   */
-  private decodeGroupCwd(groupName: string, groupDir: string): string {
-    const fromFile = safeReadFile(path.join(groupDir, CWD_FILE));
-    if (fromFile !== undefined && fromFile.trim()) return fromFile.trim();
-    try {
-      return decodeURIComponent(groupName);
-    } catch {
-      return "";
-    }
-  }
-}

package/src/providers/grok/GrokSessionParser.ts

@@ -1,166 +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";
-
-export const CHAT_HISTORY_FILE = "chat_history.jsonl";
-const IDLE_THRESHOLD_MINUTES = 5;
-
-/** One line of chat_history.jsonl. */
-interface ChatRecord {
-  type?: string;
-  content?: unknown;
-}
-
-interface ChatScan {
-  messages: ConversationMessage[];
-  firstUserMessage?: string;
-  lastUserMessage?: string;
-  lastRole?: ConversationMessage["role"];
-}
-
-/** Parsed state for a single ~/.grok/sessions/<cwd>/<id>/ directory. */
-export interface GrokSession {
-  sessionId: string;
-  projectPath: string;
-  sessionFilePath: string;
-  sessionStart: Date;
-  lastActive: Date;
-  firstUserMessage?: string;
-  lastUserMessage?: string;
-  lastRole?: ConversationMessage["role"];
-}
-
-export class GrokSessionParser {
-  /**
-   * Parse a session directory into a {@link GrokSession} from its
-   * chat_history.jsonl transcript. Returns null when the transcript is
-   * missing — i.e. there is no real session to surface.
-   */
-  readSession(sessionDir: string, defaultCwd: string): GrokSession | null {
-    const chatPath = path.join(sessionDir, CHAT_HISTORY_FILE);
-    const chatStat = safeStat(chatPath);
-    if (!chatStat) return null;
-
-    const scan = this.parseChatHistory(chatPath, false);
-    const dirStat = safeStat(sessionDir);
-    const lastActive = chatStat.mtime;
-
-    return {
-      sessionId: path.basename(sessionDir),
-      projectPath: defaultCwd,
-      sessionFilePath: chatPath,
-      sessionStart: dirStat?.birthtime || lastActive,
-      lastActive,
-      firstUserMessage: scan.firstUserMessage,
-      lastUserMessage: scan.lastUserMessage,
-      lastRole: scan.lastRole,
-    };
-  }
-
-  /** Accepts a session dir or an explicit chat_history.jsonl path. */
-  getConversation(sessionPath: string, options?: { verbose?: boolean }): ConversationMessage[] {
-    return this.parseChatHistory(this.resolveChatPath(sessionPath), options?.verbose ?? false)
-      .messages;
-  }
-
-  /**
-   * Determine agent status from parsed session state.
-   *
-   * - past the idle threshold → IDLE
-   * - last transcript turn is an assistant message → WAITING (awaiting user)
-   * - otherwise (last turn was a user message, or unknown) → RUNNING
-   */
-  determineStatus(session: GrokSession): AgentStatus {
-    const diffMinutes = (Date.now() - session.lastActive.getTime()) / 60000;
-    if (diffMinutes > IDLE_THRESHOLD_MINUTES) {
-      return AgentStatus.IDLE;
-    }
-    if (session.lastRole === "assistant") {
-      return AgentStatus.WAITING;
-    }
-    return AgentStatus.RUNNING;
-  }
-
-  /**
-   * Single pass over chat_history.jsonl. Each line is a
-   * { type: 'system' | 'user' | 'assistant', content } record where content is
-   * either a string or an array of { type: 'text', text } blocks.
-   *
-   * Grok wraps the real user prompt in <user_query>...</user_query>; the other
-   * user records are context injections (<user_info>, <system-reminder>, ...)
-   * and are skipped so the summary is the actual prompt, not boilerplate.
-   */
-  private parseChatHistory(chatPath: string, verbose: boolean): ChatScan {
-    const content = safeReadFile(chatPath);
-    if (content === undefined) return { messages: [] };
-
-    const messages: ConversationMessage[] = [];
-    let lastRole: ConversationMessage["role"] | undefined;
-
-    for (const line of content.trim().split("\n")) {
-      if (!line.trim()) continue;
-
-      let record: ChatRecord;
-      try {
-        record = JSON.parse(line);
-      } catch {
-        continue;
-      }
-
-      const text = this.extractText(record.content);
-      if (record.type === "user") {
-        const query = this.extractUserQuery(text);
-        if (query === null) continue; // context injection, not a real prompt
-        messages.push({ role: "user", content: query });
-        lastRole = "user";
-      } else if (record.type === "assistant") {
-        if (!text) continue;
-        messages.push({ role: "assistant", content: text });
-        lastRole = "assistant";
-      } else if (verbose && record.type === "system") {
-        if (!text) continue;
-        messages.push({ role: "system", content: text });
-      }
-    }
-
-    const userTurns = messages.filter((m) => m.role === "user");
-    return {
-      messages,
-      firstUserMessage: userTurns[0]?.content,
-      lastUserMessage: userTurns[userTurns.length - 1]?.content,
-      lastRole,
-    };
-  }
-
-  /** Flatten a chat record's content (string or text-block array) to text. */
-  private extractText(content: unknown): string {
-    if (typeof content === "string") return content;
-    if (Array.isArray(content)) {
-      return content
-        .map((block) =>
-          block &&
-          typeof block === "object" &&
-          typeof (block as { text?: unknown }).text === "string"
-            ? (block as { text: string }).text
-            : "",
-        )
-        .join("");
-    }
-    return "";
-  }
-
-  /**
-   * Extract the prompt inside <user_query>...</user_query>. Returns null when
-   * the record has no such tag (a context injection rather than a prompt).
-   */
-  private extractUserQuery(text: string): string | null {
-    const match = text.match(/<user_query>\s*([\s\S]*?)\s*<\/user_query>/);
-    return match ? match[1].trim() : null;
-  }
-
-  /** Resolve a session dir or an explicit chat_history.jsonl path to the file. */
-  private resolveChatPath(sessionPath: string): string {
-    return sessionPath.endsWith(".jsonl") ? sessionPath : path.join(sessionPath, CHAT_HISTORY_FILE);
-  }
-}

package/src/providers/opencode/OpenCodeAdapter.ts

@@ -1,116 +0,0 @@
-/**
- * OpenCode Adapter
- *
- * Detects running OpenCode agents by:
- * 1. Filtering OpenCode processes from a shared asynchronous process snapshot
- * 2. Using snapshot CWD and start-time enrichment
- * 3. Querying OpenCode's SQLite DB (~/.local/share/opencode/opencode.db) to
- *    find the session matching each process's CWD and read status from message.time.completed
- *
- * sessionFilePath encodes "<dbPath>::<sessionId>" so getConversation() can open the right
- * DB row without extending the AgentAdapter interface.
- */
-
-import type {
-  AgentAdapter,
-  AgentInfo,
-  ProcessInfo,
-  ConversationMessage,
-  SessionSummary,
-  ListSessionsOptions,
-  AgentDetectionContext,
-} from "../../adapters/AgentAdapter.js";
-import {
-  captureProcessSnapshot,
-  executableBasename,
-  filterByProcessNames,
-} from "../../utils/process.js";
-import { OpenCodeAgentMapper } from "./OpenCodeAgentMapper.js";
-import { OpenCodeSessionLocator } from "./OpenCodeSessionLocator.js";
-import { OpenCodeSessionParser } from "./OpenCodeSessionParser.js";
-
-const SESSION_REF_SEP = "::";
-
-function decodeSessionRef(ref: string): { sessionId: string } | null {
-  const idx = ref.lastIndexOf(SESSION_REF_SEP);
-  if (idx === -1) return null;
-  return { sessionId: ref.slice(idx + SESSION_REF_SEP.length) };
-}
-
-export class OpenCodeAdapter implements AgentAdapter {
-  readonly type = "opencode" as const;
-  readonly processNames = ["opencode"] as const;
-
-  private readonly parser: OpenCodeSessionParser;
-  private readonly locator: OpenCodeSessionLocator;
-  private readonly mapper: OpenCodeAgentMapper;
-  private readonly cleanup = (): void => this.close();
-
-  constructor(dbPath?: string) {
-    this.parser = new OpenCodeSessionParser();
-    this.locator = new OpenCodeSessionLocator(dbPath, this.parser);
-    this.mapper = new OpenCodeAgentMapper(this.locator.dbFilePath);
-    process.once("exit", this.cleanup);
-    process.once("SIGINT", this.cleanup);
-    process.once("SIGTERM", this.cleanup);
-  }
-
-  close(): void {
-    process.off("exit", this.cleanup);
-    process.off("SIGINT", this.cleanup);
-    process.off("SIGTERM", this.cleanup);
-    this.locator.close();
-  }
-
-  canHandle(processInfo: ProcessInfo): boolean {
-    const base = executableBasename(processInfo.command);
-    return base === "opencode" || base === "opencode.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 db = this.locator.openDb();
-    if (!db) return processes.map((process) => this.mapper.mapProcessOnlyAgent(process));
-
-    const agents: AgentInfo[] = [];
-    for (const proc of processes) {
-      if (!proc.cwd) {
-        agents.push(this.mapper.mapProcessOnlyAgent(proc));
-        continue;
-      }
-
-      const session = this.locator.findSessionForDirectory(db, proc.cwd);
-      if (!session) {
-        agents.push(this.mapper.mapProcessOnlyAgent(proc));
-        continue;
-      }
-
-      const stats = this.parser.getSessionStats(db, session.sessionId);
-      agents.push(this.mapper.mapSessionToAgent(session, stats, proc));
-    }
-
-    return agents;
-  }
-
-  getConversation(sessionFilePath: string, options?: { verbose?: boolean }): ConversationMessage[] {
-    const ref = decodeSessionRef(sessionFilePath);
-    if (!ref) return [];
-
-    const db = this.locator.openDb();
-    if (!db) return [];
-
-    return this.parser.getConversation(db, ref.sessionId, options);
-  }
-
-  async listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]> {
-    return this.locator.listSessions(opts);
-  }
-
-  async findSessionsById(sessionId: string): Promise<SessionSummary[]> {
-    return this.locator.findSessionsById(sessionId);
-  }
-}

package/src/providers/opencode/OpenCodeAgentMapper.ts

@@ -1,61 +0,0 @@
-import type { AgentInfo, ProcessInfo } from "../../adapters/AgentAdapter.js";
-import { AgentStatus } from "../../adapters/AgentAdapter.js";
-import { generateAgentName } from "../../utils/matching.js";
-import type { OpenCodeSession } from "./OpenCodeSessionLocator.js";
-import type { OpenCodeSessionStats } from "./OpenCodeSessionParser.js";
-
-const SESSION_REF_SEP = "::";
-const IDLE_THRESHOLD_MINUTES = 5;
-
-function encodeSessionRef(dbPath: string, sessionId: string): string {
-  return `${dbPath}${SESSION_REF_SEP}${sessionId}`;
-}
-
-export class OpenCodeAgentMapper {
-  constructor(private readonly dbPath: string) {}
-
-  mapSessionToAgent(
-    session: OpenCodeSession,
-    stats: OpenCodeSessionStats,
-    proc: ProcessInfo,
-  ): AgentInfo {
-    const lastActive =
-      stats.lastTimeUpdated > 0 ? new Date(stats.lastTimeUpdated) : new Date(session.timeCreated);
-
-    return {
-      name: generateAgentName(session.directory || proc.cwd || "", proc.pid),
-      type: "opencode",
-      status: this.determineStatus(stats, lastActive),
-      summary: stats.summary || "OpenCode session active",
-      pid: proc.pid,
-      projectPath: session.directory || proc.cwd || "",
-      sessionId: session.sessionId,
-      lastActive,
-      sessionFilePath: encodeSessionRef(this.dbPath, session.sessionId),
-    };
-  }
-
-  mapProcessOnlyAgent(proc: ProcessInfo): AgentInfo {
-    return {
-      name: generateAgentName(proc.cwd || "", proc.pid),
-      type: "opencode",
-      status: AgentStatus.RUNNING,
-      summary: "OpenCode process running",
-      pid: proc.pid,
-      projectPath: proc.cwd || "",
-      sessionId: `pid-${proc.pid}`,
-      lastActive: new Date(),
-    };
-  }
-
-  private determineStatus(stats: OpenCodeSessionStats, lastActive: Date): AgentStatus {
-    const ageMin = (Date.now() - lastActive.getTime()) / 60000;
-    if (ageMin > IDLE_THRESHOLD_MINUTES) return AgentStatus.IDLE;
-
-    if (stats.lastRole === "assistant" && !stats.lastAssistantCompleted) {
-      return AgentStatus.RUNNING;
-    }
-    if (stats.lastRole === "assistant") return AgentStatus.WAITING;
-    return AgentStatus.RUNNING;
-  }
-}

package/src/providers/opencode/OpenCodeSessionLocator.ts

@@ -1,151 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import Database from "better-sqlite3";
-import type { ListSessionsOptions, SessionSummary } from "../../adapters/AgentAdapter.js";
-import { OpenCodeSessionParser } from "./OpenCodeSessionParser.js";
-
-const SESSION_REF_SEP = "::";
-
-function encodeOpenCodeSessionRef(dbPath: string, sessionId: string): string {
-  return `${dbPath}${SESSION_REF_SEP}${sessionId}`;
-}
-
-export interface OpenCodeSession {
-  sessionId: string;
-  directory: string;
-  timeCreated: number;
-}
-
-interface OpenCodeSessionRow {
-  id: string;
-  directory: string;
-  timeCreated: number;
-}
-
-export class OpenCodeSessionLocator {
-  private readonly dbPath: string;
-  private db: Database.Database | null = null;
-
-  constructor(
-    dbPath = OpenCodeSessionLocator.resolveDbPath(),
-    private readonly parser: OpenCodeSessionParser = new OpenCodeSessionParser(),
-  ) {
-    this.dbPath = dbPath;
-  }
-
-  static resolveDbPath(): string {
-    const xdg = process.env.XDG_DATA_HOME;
-    const home = process.env.HOME || process.env.USERPROFILE || "";
-    const base = xdg || path.join(home, ".local", "share");
-    return path.join(base, "opencode", "opencode.db");
-  }
-
-  openDb(): Database.Database | null {
-    if (this.db) return this.db;
-    if (!fs.existsSync(this.dbPath)) return null;
-
-    try {
-      this.db = new Database(this.dbPath, { readonly: true });
-      return this.db;
-    } catch {
-      return null;
-    }
-  }
-
-  close(): void {
-    if (this.db) {
-      try {
-        this.db.close();
-      } catch {
-        /* ignore */
-      }
-      this.db = null;
-    }
-  }
-
-  findSessionForDirectory(db: Database.Database, directory: string): OpenCodeSession | null {
-    try {
-      const row = db
-        .prepare<[string], { id: string; directory: string; time_created: number }>(`
-                SELECT id, directory, time_created
-                FROM session
-                WHERE directory = ?
-                ORDER BY time_created DESC
-                LIMIT 1
-            `)
-        .get(directory);
-
-      if (!row) return null;
-      return { sessionId: row.id, directory: row.directory, timeCreated: row.time_created };
-    } catch {
-      return null;
-    }
-  }
-
-  listSessions(opts?: ListSessionsOptions): SessionSummary[] {
-    const db = this.openDb();
-    if (!db) return [];
-
-    try {
-      const rows = db
-        .prepare<[], OpenCodeSessionRow>(`
-                SELECT id, directory, time_created AS timeCreated
-                FROM session
-                ORDER BY time_created DESC
-            `)
-        .all();
-
-      const summaries: SessionSummary[] = [];
-
-      for (const row of rows) {
-        if (opts?.cwd !== undefined && row.directory !== opts.cwd) continue;
-
-        summaries.push(this.toSessionSummary(db, row));
-      }
-
-      return summaries;
-    } catch {
-      this.close();
-      return [];
-    }
-  }
-
-  findSessionsById(sessionId: string): SessionSummary[] {
-    const db = this.openDb();
-    if (!db) return [];
-
-    try {
-      const row = db
-        .prepare<[string], OpenCodeSessionRow>(`
-                SELECT id, directory, time_created AS timeCreated
-                FROM session
-                WHERE id = ?
-            `)
-        .get(sessionId);
-      return row ? [this.toSessionSummary(db, row)] : [];
-    } catch {
-      this.close();
-      return [];
-    }
-  }
-
-  private toSessionSummary(db: Database.Database, row: OpenCodeSessionRow): SessionSummary {
-    const stats = this.parser.getSessionStats(db, row.id);
-    const lastActive =
-      stats.lastTimeUpdated > 0 ? new Date(stats.lastTimeUpdated) : new Date(row.timeCreated);
-
-    return {
-      type: "opencode",
-      sessionId: row.id,
-      cwd: row.directory,
-      firstUserMessage: stats.summary,
-      lastActive,
-      startedAt: new Date(row.timeCreated),
-      sessionFilePath: encodeOpenCodeSessionRef(this.dbPath, row.id),
-    };
-  }
-
-  get dbFilePath(): string {
-    return this.dbPath;
-  }
-}