@ai-devkit/agent-manager 0.36.0 → 0.38.0

package/src/harnesses/opencode/OpenCodeSessionLocator.ts

@@ -0,0 +1,151 @@
+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";
+import { homeDir } from "../shared.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 base = xdg || path.join(homeDir(), ".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;
+  }
+}

package/src/harnesses/opencode/OpenCodeSessionParser.ts

@@ -0,0 +1,146 @@
+import type { ConversationMessage, ConversationOptions } from "../../adapters/AgentAdapter.js";
+import { sliceTail } from "../../utils/jsonlTail.js";
+import type Database from "better-sqlite3";
+
+export interface OpenCodeSessionStats {
+  lastRole: string | null;
+  lastTimeUpdated: number;
+  /** OpenCode writes `time.completed` on the assistant message only when the turn finishes. */
+  lastAssistantCompleted: boolean;
+  lastAssistantErrored: boolean;
+  summary: string;
+}
+
+interface OpenCodePartData {
+  type?: string;
+  text?: string;
+  reasoning?: string;
+  tool?: string;
+}
+
+const EMPTY_STATS: OpenCodeSessionStats = {
+  lastRole: null,
+  lastTimeUpdated: 0,
+  lastAssistantCompleted: false,
+  lastAssistantErrored: false,
+  summary: "",
+};
+
+export class OpenCodeSessionParser {
+  getConversation(
+    db: Database.Database,
+    sessionId: string,
+    options?: ConversationOptions,
+  ): ConversationMessage[] {
+    const verbose = options?.verbose ?? false;
+
+    try {
+      const rows = db
+        .prepare<[string], { role: string; partData: string; timeCreated: number }>(`
+                SELECT json_extract(m.data, '$.role') AS role,
+                       p.data AS partData,
+                       p.time_created AS timeCreated
+                FROM part p
+                JOIN message m ON p.message_id = m.id
+                WHERE p.session_id = ?
+                ORDER BY p.time_created ASC
+            `)
+        .all(sessionId);
+
+      const messages: ConversationMessage[] = [];
+
+      for (const row of rows) {
+        const partData = this.parsePartData(row.partData);
+        if (!partData) continue;
+
+        const role = row.role === "user" ? "user" : "assistant";
+
+        if (partData.type === "text" && partData.text) {
+          messages.push({ role, content: partData.text });
+        } else if (partData.type === "reasoning" && verbose) {
+          const text = partData.reasoning || partData.text || "";
+          if (text) messages.push({ role: "assistant", content: `[thinking] ${text}` });
+        } else if (partData.type === "tool" && verbose) {
+          const toolName = partData.tool || "tool";
+          messages.push({ role: "assistant", content: `[tool: ${toolName}]` });
+        }
+      }
+
+      return sliceTail(messages, options?.tail);
+    } catch {
+      return [];
+    }
+  }
+
+  getSessionStats(db: Database.Database, sessionId: string): OpenCodeSessionStats {
+    try {
+      // Order by time_created — time_updated can lag when OpenCode appends
+      // metadata (e.g. summary diffs) to user messages after a turn finishes.
+      const last = db
+        .prepare<[string], { role: string; timeUpdated: number }>(`
+                SELECT json_extract(data, '$.role') AS role,
+                       time_updated AS timeUpdated
+                FROM message
+                WHERE session_id = ?
+                ORDER BY time_created DESC
+                LIMIT 1
+            `)
+        .get(sessionId);
+
+      const heartbeat = db
+        .prepare<[string], { maxUpdated: number }>(`
+                SELECT MAX(time_updated) AS maxUpdated FROM message WHERE session_id = ?
+            `)
+        .get(sessionId);
+
+      const lastAssistant = db
+        .prepare<
+          [string],
+          {
+            completed: number | null;
+            errored: number | null;
+          }
+        >(`
+                SELECT json_extract(data, '$.time.completed') AS completed,
+                       json_extract(data, '$.time.error') AS errored
+                FROM message
+                WHERE session_id = ? AND json_extract(data, '$.role') = 'assistant'
+                ORDER BY time_created DESC
+                LIMIT 1
+            `)
+        .get(sessionId);
+
+      const first = db
+        .prepare<[string], { text: string }>(`
+                SELECT json_extract(p.data, '$.text') AS text
+                FROM part p
+                JOIN message m ON p.message_id = m.id
+                WHERE p.session_id = ?
+                  AND json_extract(m.data, '$.role') = 'user'
+                  AND json_extract(p.data, '$.type') = 'text'
+                  AND json_extract(p.data, '$.text') IS NOT NULL
+                ORDER BY p.time_created ASC
+                LIMIT 1
+            `)
+        .get(sessionId);
+
+      return {
+        lastRole: last?.role ?? null,
+        lastTimeUpdated: heartbeat?.maxUpdated ?? last?.timeUpdated ?? 0,
+        lastAssistantCompleted: lastAssistant?.completed != null,
+        lastAssistantErrored: lastAssistant?.errored != null,
+        summary: first?.text?.trim() ?? "",
+      };
+    } catch {
+      return EMPTY_STATS;
+    }
+  }
+
+  private parsePartData(partData: string): OpenCodePartData | null {
+    try {
+      return JSON.parse(partData) as OpenCodePartData;
+    } catch {
+      return null;
+    }
+  }
+}

package/src/harnesses/opencode/readiness.ts

@@ -0,0 +1,48 @@
+import type {
+  AuthReadinessCheck,
+  HarnessReadinessProfile,
+  ReadinessRuntime,
+} from "../readiness/types.js";
+
+const ANSI_ESCAPE_PATTERN = new RegExp(`${String.fromCharCode(27)}\\[[0-?]*[ -/]*[@-~]`, "g");
+
+function authProviderNames(output: string): string[] {
+  const names = new Set<string>();
+  for (const line of output.replace(ANSI_ESCAPE_PATTERN, "").split(/\r?\n/)) {
+    const match = /^\s*[●*+-]\s+(.+?)\s*$/.exec(line);
+    if (!match) continue;
+    const name = match[1].replace(/\s+(?:api|oauth|[\w-]*token|[A-Z][A-Z0-9_]+)$/i, "").trim();
+    if (name && !/^\d+\s+(?:credentials?|environment variables?)$/i.test(name)) names.add(name);
+  }
+  return [...names].sort();
+}
+
+async function authCheck(runtime: ReadinessRuntime): Promise<AuthReadinessCheck> {
+  try {
+    const result = await runtime.runCommand("opencode", ["auth", "list"]);
+    const availableProviders = authProviderNames(result.stdout);
+    const authenticated = availableProviders.length > 0;
+    return {
+      state: authenticated ? "authenticated" : "unauthenticated",
+      source: "opencode auth list",
+      provider: null,
+      availableProviders,
+      status: authenticated ? "pass" : "fail",
+      errors: authenticated ? [] : ["OpenCode has no configured credentials"],
+    };
+  } catch {
+    return {
+      state: "unknown",
+      source: "opencode auth list",
+      provider: null,
+      availableProviders: [],
+      status: "warn",
+      errors: ["OpenCode authentication probe failed"],
+    };
+  }
+}
+
+export const openCodeReadiness: HarnessReadinessProfile = {
+  configDir: ".config/opencode",
+  auth: authCheck,
+};

package/src/harnesses/pi/PiAdapter.ts

@@ -0,0 +1,197 @@
+import * as fs from "fs";
+import * as path from "path";
+import type {
+  AgentAdapter,
+  AgentInfo,
+  ProcessInfo,
+  ConversationMessage,
+  ConversationOptions,
+  SessionSummary,
+  ListSessionsOptions,
+  AgentDetectionContext,
+} from "../../adapters/AgentAdapter.js";
+import { executableBasename } 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";
+import { findHarnessProcesses, homeDir } from "../shared.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;
+  /** Kept across refreshes so live discovery can reuse its head and no-match caches. */
+  private readonly liveLocator: PiSessionLocator;
+
+  constructor(registry: AgentRegistry = AgentRegistry.default()) {
+    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);
+    this.liveLocator = this.createLocator();
+  }
+
+  canHandle(processInfo: ProcessInfo): boolean {
+    return this.isPiExecutable(processInfo.command);
+  }
+
+  async detectAgents(context?: AgentDetectionContext): Promise<AgentInfo[]> {
+    try {
+      return await this.detectRunningAgents(context);
+    } finally {
+      // Drop cached summaries for sessions that were not part of this refresh
+      this.parser.pruneSessionCache();
+    }
+  }
+
+  private async detectRunningAgents(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.liveLocator.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?: ConversationOptions): 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;
+  }
+
+  async findSessionsById(sessionId: string): Promise<SessionSummary[]> {
+    const summaries: SessionSummary[] = [];
+    const filePaths = this.createLocator().findHistoricalSessionFilesById(sessionId);
+    for (const filePath of filePaths) {
+      const summary = this.parser.fileToSessionSummary(filePath);
+      if (summary?.sessionId === sessionId) summaries.push(summary);
+    }
+
+    if (summaries.length > 0) return summaries;
+    return (await this.listSessions()).filter((summary) => summary.sessionId === sessionId);
+  }
+
+  private async getPiProcesses(context?: AgentDetectionContext): Promise<ProcessInfo[]> {
+    return (await findHarnessProcesses(this, context)).processes;
+  }
+
+  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.readSessionIncremental(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/harnesses/pi/PiAgentMapper.ts

@@ -0,0 +1,27 @@
+import type { AgentInfo, ProcessInfo } from "../../adapters/AgentAdapter.js";
+import { generateAgentName } from "../../utils/matching.js";
+import { type PiSession, PiSessionParser } from "./PiSessionParser.js";
+import { processOnlyAgent } from "../shared.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 processOnlyAgent("pi", processInfo, { summary: "Pi process running" });
+  }
+}