@ai-devkit/agent-manager 0.38.0 → 0.39.0

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/readiness/AgentReadiness.ts

@@ -3,6 +3,7 @@ import { codexReadiness } from "../codex/readiness.js";
 import { copilotReadiness } from "../copilot/readiness.js";
 import { openCodeReadiness } from "../opencode/readiness.js";
 import { piReadiness } from "../pi/readiness.js";
+import { devinReadiness } from "../devin/readiness.js";
 import {
   builtInSkillsCheck,
   createReadinessRuntime,
@@ -29,6 +30,7 @@ const READINESS_PROFILES: Record<ReadinessAgentType, HarnessReadinessProfile> =
   opencode: openCodeReadiness,
   copilot: copilotReadiness,
   pi: piReadiness,
+  devin: devinReadiness,
 };
 
 export async function getAgentReadinessReport(

package/src/harnesses/runtimeProfiles.ts

@@ -21,6 +21,7 @@ export const HARNESS_RUNTIME_PROFILES: Record<StartableAgentType, HarnessRuntime
   opencode: profile("opencode", matchArgv0("opencode")),
   pi: profile("pi", matchAnyBasename(["pi"])),
   kiro: profile("kiro", matchAnyBasename(["kiro-cli", "kiro"]), ["kiro_cli", "kiro-cli"]),
+  devin: profile("devin", matchArgv0("devin")),
 };
 
 export function runtimeAgentMatchesHarness(runtimeAgent: string, type: AgentType): boolean {

package/src/terminal/TtyWriter.ts

@@ -1,13 +1,14 @@
-import { terminalBackendFor } from "./backends/index.js";
+import { TERMINAL_BACKENDS, terminalBackendFor } from "./backends/index.js";
 import type { TerminalLocation } from "./types.js";
 
+const SUPPORTED = `Supported: ${TERMINAL_BACKENDS.map((backend) => backend.label).join(", ")}.`;
+
 export class TtyWriter {
   static async send(location: TerminalLocation, message: string): Promise<void> {
     const backend = terminalBackendFor(location.type);
     if (!backend) {
       throw new Error(
-        `Cannot send input: unsupported terminal type "${location.type}". ` +
-          "Supported: tmux, WezTerm, iTerm2, Terminal.app.",
+        `Cannot send input: unsupported terminal type "${location.type}". ${SUPPORTED}`,
       );
     }
     await backend.send(location, message);
@@ -17,8 +18,7 @@ export class TtyWriter {
     const backend = terminalBackendFor(location.type);
     if (!backend) {
       throw new Error(
-        `Cannot send key: unsupported terminal type "${location.type}". ` +
-          "Supported: tmux, WezTerm, iTerm2, Terminal.app.",
+        `Cannot send key: unsupported terminal type "${location.type}". ${SUPPORTED}`,
       );
     }
     await backend.sendKey(location, key);

package/src/terminal/backends/ghostty.ts

@@ -0,0 +1,180 @@
+import { execFile } from "child_process";
+import { writeFile } from "fs/promises";
+import { promisify } from "util";
+import { escapeAppleScript } from "../../utils/applescript.js";
+import { getProcessCwdsAsync } from "../../utils/process.js";
+import { TerminalType, type TerminalBackend, type TerminalLocation } from "../types.js";
+import { CARRIAGE_RETURN, isProcessName, sleep } from "./shared.js";
+
+const execFileAsync = promisify(execFile);
+
+/** Separates fields in AppleScript output; never part of an id, title or path. */
+const FIELD_SEPARATOR = "\x1f";
+const MARKER_POLL_ATTEMPTS = 10;
+const MARKER_POLL_INTERVAL_MS = 50;
+
+interface GhosttyTerminal {
+  id: string;
+  name: string;
+  workingDirectory: string;
+}
+
+interface ProcessRow {
+  pid: number;
+  ppid: number;
+  tty: string;
+  comm: string;
+}
+
+async function listProcesses(): Promise<ProcessRow[]> {
+  const { stdout } = await execFileAsync("ps", ["-Axo", "pid=,ppid=,tty=,comm="]);
+  const rows: ProcessRow[] = [];
+  for (const line of stdout.split("\n")) {
+    const match = line.trim().match(/^(\d+)\s+(\d+)\s+(\S+)\s+(.+)$/);
+    if (match) {
+      rows.push({ pid: Number(match[1]), ppid: Number(match[2]), tty: match[3], comm: match[4] });
+    }
+  }
+  return rows;
+}
+
+async function listTerminals(): Promise<GhosttyTerminal[]> {
+  const script = `
+tell application "Ghostty"
+  set out to ""
+  repeat with t in terminals
+    set out to out & (id of t) & (character id 31) & (name of t) & (character id 31) & (working directory of t) & linefeed
+  end repeat
+  return out
+end tell`;
+  const { stdout } = await execFileAsync("osascript", ["-e", script]);
+  return stdout
+    .split("\n")
+    .map((line) => line.split(FIELD_SEPARATOR))
+    .filter((fields) => fields.length === 3 && fields[0])
+    .map(([id, name, workingDirectory]) => ({ id, name, workingDirectory }));
+}
+
+/** Run an AppleScript `command` with `t` bound to the located terminal; false if it is gone. */
+async function onTerminal(location: TerminalLocation, command: string): Promise<boolean> {
+  const script = `
+tell application "Ghostty"
+  set matches to (every terminal whose id is "${escapeAppleScript(location.identifier)}")
+  if (count of matches) is 0 then return "not_found"
+  set t to item 1 of matches
+  ${command}
+end tell
+return "ok"`;
+  const { stdout } = await execFileAsync("osascript", ["-e", script]);
+  return stdout.trim() === "ok";
+}
+
+/** Set the window title of whatever terminal owns `tty` (OSC 2). */
+async function writeTitle(tty: string, title: string): Promise<void> {
+  // eslint-disable-next-line no-control-regex
+  const safe = title.replace(/[\x00-\x1f\x7f]/g, "");
+  await writeFile(tty, `\x1b]2;${safe}\x07`, { flag: "a" });
+}
+
+/**
+ * Ghostty's AppleScript terminals expose an id, title and working directory,
+ * but not their TTY. Find the one owning `tty` without guessing:
+ * 1. only TTYs whose session was started by a ghostty process qualify;
+ * 2. if exactly one terminal's working directory matches a process on this
+ *    TTY, and no other Ghostty TTY has a process there, that is it;
+ * 3. otherwise briefly set a unique title on the TTY, find the terminal now
+ *    showing it, and restore its previous title.
+ */
+async function findTerminalId(tty: string): Promise<string | null> {
+  const processes = await listProcesses();
+  const ghosttyPids = new Set(
+    processes.filter((p) => isProcessName(p.comm, "ghostty")).map((p) => p.pid),
+  );
+  if (ghosttyPids.size === 0) return null;
+
+  const ttyName = tty.replace(/^\/dev\//, "");
+  const ghosttyTtys = new Set(
+    processes.filter((p) => ghosttyPids.has(p.ppid) && p.tty !== "??").map((p) => p.tty),
+  );
+  if (!ghosttyTtys.has(ttyName)) return null;
+
+  const terminals = await listTerminals();
+  const sessionProcesses = processes.filter((p) => ghosttyTtys.has(p.tty));
+  const cwdByPid = await getProcessCwdsAsync(sessionProcesses.map((p) => p.pid));
+  const ownDirs = new Set<string>();
+  const otherDirs = new Set<string>();
+  for (const p of sessionProcesses) {
+    const cwd = cwdByPid.get(p.pid);
+    if (cwd) (p.tty === ttyName ? ownDirs : otherDirs).add(cwd);
+  }
+
+  // Trust the directory only when exactly one terminal is in a folder no other Ghostty TTY uses.
+  const byDirectory = terminals.filter((t) => ownDirs.has(t.workingDirectory));
+  if (byDirectory.length === 1 && !otherDirs.has(byDirectory[0].workingDirectory)) {
+    return byDirectory[0].id;
+  }
+
+  const marker = `ai-devkit-${process.pid}-${Date.now()}`;
+  await writeTitle(tty, marker);
+  for (let attempt = 0; attempt < MARKER_POLL_ATTEMPTS; attempt++) {
+    const marked = (await listTerminals()).find((t) => t.name === marker);
+    if (marked) {
+      const previous = terminals.find((t) => t.id === marked.id)?.name ?? "";
+      await writeTitle(tty, previous);
+      return marked.id;
+    }
+    await sleep(MARKER_POLL_INTERVAL_MS);
+  }
+  return null;
+}
+
+/**
+ * A Ghostty `text:` action that writes `bytes` to the terminal as typed.
+ * Unlike `send key`, it does not go through the keyboard layout or input
+ * method, which can turn a digit key into another character.
+ */
+function textAction(bytes: string): string {
+  const escaped = Array.from(bytes, (char) => {
+    if (char === "\\") return "\\\\";
+    const code = char.charCodeAt(0);
+    return code >= 0x20 && code < 0x7f ? char : `\\x${code.toString(16).padStart(2, "0")}`;
+  }).join("");
+  return `perform action "${escapeAppleScript(`text:${escaped}`)}" on t`;
+}
+
+export const ghosttyBackend: TerminalBackend = {
+  type: TerminalType.GHOSTTY,
+  label: "Ghostty",
+
+  async find(tty) {
+    try {
+      const id = await findTerminalId(tty);
+      return id ? { type: TerminalType.GHOSTTY, identifier: id, tty } : null;
+    } catch {
+      // Ghostty not installed, not scriptable, or the TTY is not writable
+      return null;
+    }
+  },
+
+  async focus(location) {
+    return onTerminal(location, "focus t\n  activate");
+  },
+
+  async send(location, message) {
+    if (!(await onTerminal(location, `input text "${escapeAppleScript(message)}" to t`))) {
+      throw new Error(`Ghostty terminal not found for TTY ${location.tty}`);
+    }
+    await sleep(150);
+    if (!(await onTerminal(location, textAction(CARRIAGE_RETURN)))) {
+      throw new Error(
+        `Ghostty terminal disappeared before Enter could be sent for TTY ${location.tty}`,
+      );
+    }
+  },
+
+  async sendKey(location, key) {
+    if (!(await onTerminal(location, textAction(key)))) {
+      throw new Error(`Ghostty terminal not found for TTY ${location.tty}`);
+    }
+  },
+};

package/src/terminal/backends/index.ts

@@ -1,5 +1,6 @@
 import type { TerminalBackend } from "../types.js";
 import { TerminalType } from "../types.js";
+import { ghosttyBackend } from "./ghostty.js";
 import { iterm2Backend } from "./iterm2.js";
 import { terminalAppBackend } from "./terminal-app.js";
 import { tmuxBackend } from "./tmux.js";
@@ -8,6 +9,7 @@ import { weztermBackend } from "./wezterm.js";
 export const TERMINAL_BACKENDS: readonly TerminalBackend[] = [
   tmuxBackend,
   weztermBackend,
+  ghosttyBackend,
   iterm2Backend,
   terminalAppBackend,
 ];

package/src/terminal/backends/shared.ts

@@ -33,10 +33,15 @@ export function appleScriptKeyAction(key: string): string {
   return `keystroke "${escapeAppleScript(key)}"`;
 }
 
+/** Whether a `ps` comm value (bare name or full executable path) is `name`. */
+export function isProcessName(comm: string, name: string): boolean {
+  return comm === name || comm.endsWith(`/${name}`);
+}
+
 export async function isProcessRunning(name: string): Promise<boolean> {
   const { stdout } = await execFileAsync("ps", ["-Axo", "comm"]);
   return stdout
     .split("\n")
     .map((line) => line.trim())
-    .some((command) => command === name || command.endsWith(`/${name}`));
+    .some((command) => isProcessName(command, name));
 }

package/src/terminal/types.ts

@@ -1,6 +1,7 @@
 export enum TerminalType {
   TMUX = "tmux",
   WEZTERM = "wezterm",
+  GHOSTTY = "ghostty",
   ITERM2 = "iterm2",
   TERMINAL_APP = "terminal-app",
   UNKNOWN = "unknown",

package/src/utils/process.ts

@@ -221,6 +221,11 @@ function parseProcessList(output: string, namePatterns: ReadonlySet<string>): Pa
   return { allPids, matched };
 }
 
+/** Working directories of `pids` (async `lsof`); PIDs it cannot read are omitted. */
+export function getProcessCwdsAsync(pids: number[]): Promise<Map<number, string>> {
+  return batchGetProcessCwdsAsync(execFileText, pids);
+}
+
 async function batchGetProcessCwdsAsync(
   exec: ProcessExec,
   pids: number[],