@ai-devkit/agent-manager 0.37.0 → 0.39.0

package/src/harnesses/devin/DevinSessionLocator.ts

@@ -0,0 +1,230 @@
+import * as fs from "fs";
+import * as path from "path";
+import Database from "better-sqlite3";
+import type { ListSessionsOptions, SessionSummary } from "../../adapters/AgentAdapter.js";
+import { DevinSessionParser } from "./DevinSessionParser.js";
+import { homeDir } from "../shared.js";
+
+const SESSION_REF_SEP = "::";
+const LOCK_FILE_SUFFIX = ".lock";
+
+export function encodeDevinSessionRef(dbPath: string, sessionId: string): string {
+  return `${dbPath}${SESSION_REF_SEP}${sessionId}`;
+}
+
+/** Inverse of {@link encodeDevinSessionRef}; null when the ref has no separator. */
+export function decodeDevinSessionRef(ref: string): string | null {
+  const idx = ref.lastIndexOf(SESSION_REF_SEP);
+  return idx === -1 ? null : ref.slice(idx + SESSION_REF_SEP.length);
+}
+
+export interface DevinSession {
+  sessionId: string;
+  directory: string;
+  title: string | null;
+  /** Epoch milliseconds. */
+  timeCreated: number;
+  /** Epoch milliseconds. */
+  lastActivityAt: number;
+}
+
+/** A live `session_locks/<slug>.lock` entry: the session and its holder PID. */
+export interface DevinSessionLock {
+  sessionId: string;
+  pid: number;
+}
+
+interface DevinSessionRow {
+  id: string;
+  working_directory: string;
+  title: string | null;
+  created_at: number;
+  last_activity_at: number;
+}
+
+function toDevinSession(row: DevinSessionRow): DevinSession {
+  return {
+    sessionId: row.id,
+    directory: row.working_directory,
+    title: row.title,
+    timeCreated: row.created_at * 1000,
+    lastActivityAt: row.last_activity_at * 1000,
+  };
+}
+
+export class DevinSessionLocator {
+  private readonly dbPath: string;
+  private readonly locksDir: string;
+  private db: Database.Database | null = null;
+
+  constructor(
+    dbPath = DevinSessionLocator.resolveDbPath(),
+    locksDir = DevinSessionLocator.defaultLocksDir(dbPath),
+    private readonly parser: DevinSessionParser = new DevinSessionParser(),
+  ) {
+    this.dbPath = dbPath;
+    this.locksDir = locksDir;
+  }
+
+  static resolveDbPath(): string {
+    const xdg = process.env.XDG_DATA_HOME;
+    const base = xdg || path.join(homeDir(), ".local", "share");
+    return path.join(base, "devin", "cli", "sessions.db");
+  }
+
+  static defaultLocksDir(dbPath: string): string {
+    return path.join(path.dirname(dbPath), "session_locks");
+  }
+
+  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;
+    }
+  }
+
+  /**
+   * Read `session_locks/*.lock` entries. Each file name is a session slug and
+   * its body is the PID of the `devin acp` backend holding the session.
+   * Malformed files are skipped; callers validate liveness against the
+   * process snapshot.
+   */
+  listActiveLocks(): DevinSessionLock[] {
+    let entries: string[];
+    try {
+      entries = fs.readdirSync(this.locksDir);
+    } catch {
+      return [];
+    }
+
+    const locks: DevinSessionLock[] = [];
+    for (const entry of entries) {
+      if (!entry.endsWith(LOCK_FILE_SUFFIX)) continue;
+      const sessionId = entry.slice(0, -LOCK_FILE_SUFFIX.length);
+      if (!sessionId) continue;
+
+      try {
+        const raw = fs.readFileSync(path.join(this.locksDir, entry), "utf-8").trim();
+        const pid = parseInt(raw, 10);
+        if (Number.isFinite(pid) && pid > 0) locks.push({ sessionId, pid });
+      } catch {
+        /* skip unreadable lock */
+      }
+    }
+    return locks;
+  }
+
+  findSessionById(db: Database.Database, sessionId: string): DevinSession | null {
+    try {
+      const row = db
+        .prepare<[string], DevinSessionRow>(`
+                SELECT id, working_directory, title, created_at, last_activity_at
+                FROM sessions
+                WHERE id = ? AND hidden = 0
+            `)
+        .get(sessionId);
+      return row ? toDevinSession(row) : null;
+    } catch {
+      return null;
+    }
+  }
+
+  findSessionForDirectory(db: Database.Database, directory: string): DevinSession | null {
+    try {
+      const row = db
+        .prepare<[string], DevinSessionRow>(`
+                SELECT id, working_directory, title, created_at, last_activity_at
+                FROM sessions
+                WHERE working_directory = ? AND hidden = 0
+                ORDER BY last_activity_at DESC
+                LIMIT 1
+            `)
+        .get(directory);
+      return row ? toDevinSession(row) : null;
+    } catch {
+      return null;
+    }
+  }
+
+  listSessions(opts?: ListSessionsOptions): SessionSummary[] {
+    const db = this.openDb();
+    if (!db) return [];
+
+    try {
+      const rows = db
+        .prepare<[], DevinSessionRow>(`
+                SELECT id, working_directory, title, created_at, last_activity_at
+                FROM sessions
+                WHERE hidden = 0
+                ORDER BY last_activity_at DESC
+            `)
+        .all();
+
+      const summaries: SessionSummary[] = [];
+      for (const row of rows) {
+        if (opts?.cwd !== undefined && row.working_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], DevinSessionRow>(`
+                SELECT id, working_directory, title, created_at, last_activity_at
+                FROM sessions
+                WHERE id = ? AND hidden = 0
+            `)
+        .get(sessionId);
+      return row ? [this.toSessionSummary(db, row)] : [];
+    } catch {
+      this.close();
+      return [];
+    }
+  }
+
+  private toSessionSummary(db: Database.Database, row: DevinSessionRow): SessionSummary {
+    const session = toDevinSession(row);
+    return {
+      type: "devin",
+      sessionId: session.sessionId,
+      cwd: session.directory,
+      firstUserMessage: this.parser.getFirstUserMessage(db, session.sessionId),
+      lastActive: new Date(session.lastActivityAt),
+      startedAt: new Date(session.timeCreated),
+      sessionFilePath: encodeDevinSessionRef(this.dbPath, session.sessionId),
+    };
+  }
+
+  get dbFilePath(): string {
+    return this.dbPath;
+  }
+
+  get sessionLocksDir(): string {
+    return this.locksDir;
+  }
+}

package/src/harnesses/devin/DevinSessionParser.ts

@@ -0,0 +1,236 @@
+import type { ConversationMessage, ConversationOptions } from "../../adapters/AgentAdapter.js";
+import { sliceTail } from "../../utils/jsonlTail.js";
+import { SUMMARY_MAX_LENGTH, truncate } from "../shared.js";
+import type Database from "better-sqlite3";
+
+export interface DevinSessionStats {
+  lastRole: string | null;
+  /** Epoch milliseconds of the newest message node. */
+  lastTimeUpdated: number;
+  summary: string;
+}
+
+interface DevinChatMessage {
+  message_id?: string;
+  role?: string;
+  content?: unknown;
+  tool_calls?: { name?: string; function?: { name?: string } }[];
+  thinking?: { thinking?: string } | string;
+  name?: string;
+  metadata?: { is_user_input?: boolean };
+}
+
+interface MessageNodeRow {
+  node_id: number;
+  chat_message: string;
+}
+
+const EMPTY_STATS: DevinSessionStats = {
+  lastRole: null,
+  lastTimeUpdated: 0,
+  summary: "",
+};
+
+/** Rows fetched per requested tail message; revisions/tools eat into the window. */
+const TAIL_OVERFETCH = 8;
+const TOOL_CONTENT_MAX = 500;
+
+export class DevinSessionParser {
+  getConversation(
+    db: Database.Database,
+    sessionId: string,
+    options?: ConversationOptions,
+  ): ConversationMessage[] {
+    const verbose = options?.verbose ?? false;
+    const tail =
+      options?.tail && Number.isInteger(options.tail) && options.tail > 0
+        ? options.tail
+        : undefined;
+
+    try {
+      // LIMIT -1 = unbounded in SQLite; one query serves the full and tail paths.
+      const limit = tail ? tail * TAIL_OVERFETCH : -1;
+      const rows = db
+        .prepare<[string, number], MessageNodeRow>(`
+                SELECT node_id, chat_message
+                FROM message_nodes
+                WHERE session_id = ?
+                ORDER BY node_id DESC
+                LIMIT ?
+            `)
+        .all(sessionId, limit)
+        .reverse();
+
+      const messages: ConversationMessage[] = [];
+      const latestNodeByMessageId = new Map<string, number>();
+      const parsed: { nodeId: number; message: DevinChatMessage }[] = [];
+
+      for (const row of rows) {
+        const message = this.parseChatMessage(row.chat_message);
+        if (!message) continue;
+        parsed.push({ nodeId: row.node_id, message });
+        if (message.message_id) {
+          latestNodeByMessageId.set(
+            message.message_id,
+            Math.max(latestNodeByMessageId.get(message.message_id) ?? 0, row.node_id),
+          );
+        }
+      }
+
+      for (const { nodeId, message } of parsed) {
+        if (
+          message.message_id &&
+          latestNodeByMessageId.get(message.message_id) !== nodeId
+        ) {
+          continue;
+        }
+
+        const role = message.role;
+        if (role === "system") continue;
+
+        const content = typeof message.content === "string" ? message.content : "";
+
+        if (role === "user") {
+          if (message.metadata?.is_user_input === false || !content.trim()) continue;
+          messages.push({ role: "user", content });
+          continue;
+        }
+
+        if (role === "assistant") {
+          const thinking =
+            typeof message.thinking === "string"
+              ? message.thinking
+              : message.thinking?.thinking;
+          if (verbose && thinking) {
+            messages.push({ role: "assistant", content: `[thinking] ${thinking}` });
+          }
+          if (content.trim()) messages.push({ role: "assistant", content });
+          if (verbose) {
+            for (const call of message.tool_calls ?? []) {
+              const name = call.function?.name ?? call.name ?? "tool";
+              messages.push({ role: "assistant", content: `[tool: ${name}]` });
+            }
+          }
+          continue;
+        }
+
+        if (role === "tool" && verbose) {
+          const label = message.name ? `[tool: ${message.name}]` : "[tool]";
+          messages.push({
+            role: "assistant",
+            content: `${label} ${truncate(content.trim(), TOOL_CONTENT_MAX)}`.trim(),
+          });
+        }
+      }
+
+      return sliceTail(messages, tail);
+    } catch {
+      return [];
+    }
+  }
+
+  getSessionStats(db: Database.Database, sessionId: string): DevinSessionStats {
+    try {
+      const frontier = db
+        .prepare<[string], { chat_message: string }>(`
+                SELECT chat_message
+                FROM message_nodes
+                WHERE session_id = ?
+                ORDER BY node_id DESC
+                LIMIT 1
+            `)
+        .get(sessionId);
+
+      const heartbeat = db
+        .prepare<[string], { maxCreated: number | null }>(`
+                SELECT MAX(created_at) AS maxCreated
+                FROM message_nodes
+                WHERE session_id = ?
+            `)
+        .get(sessionId);
+
+      return {
+        lastRole: this.parseChatMessage(frontier?.chat_message ?? "")?.role ?? null,
+        lastTimeUpdated: (heartbeat?.maxCreated ?? 0) * 1000,
+        summary: this.getLastUserPrompt(db, sessionId),
+      };
+    } catch {
+      return EMPTY_STATS;
+    }
+  }
+
+  /**
+   * Most recent typed prompt for the "working on" summary, matching the
+   * last-user-message convention of the other adapters.
+   */
+  getLastUserPrompt(db: Database.Database, sessionId: string): string {
+    return this.userPrompt(db, sessionId, "DESC");
+  }
+
+  /**
+   * First typed prompt for session-list identity (`firstUserMessage`).
+   */
+  getFirstUserMessage(db: Database.Database, sessionId: string): string {
+    return this.userPrompt(db, sessionId, "ASC");
+  }
+
+  /**
+   * Typed prompt in the given direction. `prompt_history` is authoritative;
+   * shell `!` commands and `/` slash commands are skipped. Falls back to a
+   * bounded `is_user_input` node scan in the same direction.
+   */
+  private userPrompt(
+    db: Database.Database,
+    sessionId: string,
+    direction: "ASC" | "DESC",
+  ): string {
+    try {
+      const prompt = db
+        .prepare<[string], { content: string }>(`
+                SELECT content
+                FROM prompt_history
+                WHERE session_id = ? AND is_shell = 0 AND content NOT LIKE '/%'
+                ORDER BY timestamp ${direction}
+                LIMIT 1
+            `)
+        .get(sessionId);
+      if (prompt?.content?.trim()) return truncate(prompt.content.trim(), SUMMARY_MAX_LENGTH);
+    } catch {
+      /* fall through to message_nodes */
+    }
+
+    try {
+      const rows = db
+        .prepare<[string], { chat_message: string }>(`
+                SELECT chat_message
+                FROM message_nodes
+                WHERE session_id = ? AND json_extract(chat_message, '$.role') = 'user'
+                ORDER BY node_id ${direction}
+                LIMIT 8
+            `)
+        .all(sessionId);
+      for (const row of rows) {
+        const message = this.parseChatMessage(row.chat_message);
+        if (
+          message?.role === "user" &&
+          message.metadata?.is_user_input !== false &&
+          typeof message.content === "string" &&
+          message.content.trim()
+        ) {
+          return truncate(message.content.trim(), SUMMARY_MAX_LENGTH);
+        }
+      }
+    } catch {
+      /* ignore */
+    }
+    return "";
+  }
+
+  private parseChatMessage(raw: string): DevinChatMessage | null {
+    try {
+      return JSON.parse(raw) as DevinChatMessage;
+    } catch {
+      return null;
+    }
+  }
+}

package/src/harnesses/devin/readiness.ts

@@ -0,0 +1,36 @@
+import type {
+  AuthReadinessCheck,
+  HarnessReadinessProfile,
+  ReadinessRuntime,
+} from "../readiness/types.js";
+
+const LOGGED_IN_PATTERN = /^Logged in/m;
+
+async function authCheck(runtime: ReadinessRuntime): Promise<AuthReadinessCheck> {
+  try {
+    const result = await runtime.runCommand("devin", ["auth", "status"]);
+    const authenticated = LOGGED_IN_PATTERN.test(result.stdout);
+    return {
+      state: authenticated ? "authenticated" : "unauthenticated",
+      source: "devin auth status",
+      provider: null,
+      availableProviders: authenticated ? ["devin"] : [],
+      status: authenticated ? "pass" : "fail",
+      errors: authenticated ? [] : ["Devin is not logged in"],
+    };
+  } catch {
+    return {
+      state: "unknown",
+      source: "devin auth status",
+      provider: null,
+      availableProviders: [],
+      status: "warn",
+      errors: ["Devin authentication probe failed"],
+    };
+  }
+}
+
+export const devinReadiness: HarnessReadinessProfile = {
+  configDir: ".config/devin",
+  auth: authCheck,
+};

package/src/harnesses/index.ts

@@ -8,6 +8,7 @@ import { GrokCliAdapter } from "./grok/GrokCliAdapter.js";
 import { KiroAdapter } from "./kiro/KiroAdapter.js";
 import { OpenCodeAdapter } from "./opencode/OpenCodeAdapter.js";
 import { PiAdapter } from "./pi/PiAdapter.js";
+import { DevinAdapter } from "./devin/DevinAdapter.js";
 
 /**
  * One instance of every built-in harness adapter, in registration order
@@ -24,5 +25,6 @@ export function createBuiltinAdapters(): AgentAdapter[] {
     new AntigravityCliAdapter(),
     new OpenCodeAdapter(),
     new PiAdapter(),
+    new DevinAdapter(),
   ];
 }

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/credentials.ts

@@ -0,0 +1,129 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+type UnknownRecord = Record<string, unknown>;
+
+export type PiCredentialOptions = {
+  env?: NodeJS.ProcessEnv;
+  readFile?: (path: string, encoding: BufferEncoding) => Promise<string>;
+};
+
+export type PiAnthropicCredential = {
+  kind: "oauth";
+  access: string;
+  expiresMs: number | null;
+};
+
+export type PiOpenAiCredential =
+  | { kind: "platform"; key: string }
+  | { kind: "oauth"; access: string; accountId: string; expiresMs: number | null };
+
+const OPENAI_CREDENTIALS_MISSING =
+  "OpenAI credentials not found; set OPENAI_API_KEY, configure the Pi openai provider, or log in to OpenAI via Pi";
+const ZAI_CREDENTIAL_MISSING =
+  "z.ai API key not found; set Z_AI_API_KEY or configure Pi provider zai";
+
+function record(value: unknown): UnknownRecord | null {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as UnknownRecord)
+    : null;
+}
+
+function nonEmptyText(value: unknown): string | null {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+function epochMilliseconds(value: unknown): number | null {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return null;
+  return value > 1e12 ? value : value * 1000;
+}
+
+async function readPiAuthRoot(options: PiCredentialOptions): Promise<UnknownRecord> {
+  const env = options.env ?? process.env;
+  const authPath = join(env.HOME || homedir(), ".pi", "agent", "auth.json");
+  const contents = await (options.readFile ?? readFile)(authPath, "utf8");
+  const parsed = record(JSON.parse(contents));
+  if (!parsed) throw new Error("Pi auth file is malformed");
+  return parsed;
+}
+
+export async function resolvePiAnthropicCredential(
+  options: PiCredentialOptions = {},
+): Promise<PiAnthropicCredential> {
+  let root: UnknownRecord;
+  try {
+    root = await readPiAuthRoot(options);
+  } catch (error) {
+    if (record(error)?.code === "ENOENT") {
+      throw new Error("Pi Anthropic OAuth credentials not found");
+    }
+    throw new Error("Pi Anthropic auth file is malformed");
+  }
+
+  const credential = record(root.anthropic);
+  if (!credential) throw new Error("Pi Anthropic OAuth credentials not found");
+  const access = credential.type === "oauth" ? nonEmptyText(credential.access) : null;
+  if (!access) throw new Error("Pi Anthropic OAuth credential is malformed");
+  return {
+    kind: "oauth",
+    access,
+    expiresMs: epochMilliseconds(credential.expires),
+  };
+}
+
+export async function resolvePiOpenAiCredential(
+  options: PiCredentialOptions = {},
+): Promise<PiOpenAiCredential> {
+  const env = options.env ?? process.env;
+  const environmentKey = nonEmptyText(env.OPENAI_API_KEY);
+  if (environmentKey) return { kind: "platform", key: environmentKey };
+
+  let root: UnknownRecord;
+  try {
+    root = await readPiAuthRoot(options);
+  } catch (error) {
+    if (record(error)?.code === "ENOENT") throw new Error(OPENAI_CREDENTIALS_MISSING);
+    throw new Error("OpenAI Pi auth file is malformed");
+  }
+
+  const platform = record(root.openai);
+  if (platform) {
+    const key = platform.type === "api_key" ? nonEmptyText(platform.key) : null;
+    if (!key) throw new Error("OpenAI Pi auth file has a malformed openai credential");
+    return { kind: "platform", key };
+  }
+
+  const oauth = record(root["openai-codex"]);
+  const access = oauth?.type === "oauth" ? nonEmptyText(oauth.access) : null;
+  const accountId = nonEmptyText(oauth?.accountId);
+  if (oauth && access && accountId) {
+    return {
+      kind: "oauth",
+      access,
+      accountId,
+      expiresMs: epochMilliseconds(oauth.expires),
+    };
+  }
+  throw new Error(OPENAI_CREDENTIALS_MISSING);
+}
+
+export async function resolvePiZaiApiKey(options: PiCredentialOptions = {}): Promise<string> {
+  const env = options.env ?? process.env;
+  const environmentKey = nonEmptyText(env.Z_AI_API_KEY);
+  if (environmentKey) return environmentKey;
+
+  let root: UnknownRecord;
+  try {
+    root = await readPiAuthRoot(options);
+  } catch (error) {
+    if (record(error)?.code === "ENOENT") throw new Error(ZAI_CREDENTIAL_MISSING);
+    throw new Error("z.ai Pi auth file is malformed");
+  }
+
+  const credential = record(root.zai);
+  if (!credential) throw new Error(ZAI_CREDENTIAL_MISSING);
+  const key = credential.type === "api_key" ? nonEmptyText(credential.key) : null;
+  if (!key) throw new Error("z.ai Pi auth file has a malformed zai credential");
+  return key;
+}