@ai-devkit/agent-manager 0.33.0 → 0.34.0

package/src/__tests__/providers/opencode/OpenCodeAdapter.test.ts

@@ -0,0 +1,197 @@
+import Database from "better-sqlite3";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { AgentStatus, type ProcessInfo } from "../../../adapters/AgentAdapter.js";
+import { OpenCodeAdapter } from "../../../providers/opencode/OpenCodeAdapter.js";
+
+describe("OpenCodeAdapter", () => {
+  let adapter: OpenCodeAdapter;
+  let tmpDir: string;
+  let dbPath: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "opencode-adapter-test-"));
+    dbPath = path.join(tmpDir, "opencode.db");
+    adapter = new OpenCodeAdapter(dbPath);
+  });
+
+  afterEach(() => {
+    adapter.close();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("detects opencode executables", () => {
+    expect(adapter.canHandle({ pid: 1, command: "opencode", cwd: "/repo" })).toBe(true);
+    expect(adapter.canHandle({ pid: 2, command: "/usr/bin/opencode.exe", cwd: "/repo" })).toBe(
+      true,
+    );
+    expect(adapter.canHandle({ pid: 3, command: "node /repo/opencode-plugin.js" })).toBe(false);
+  });
+
+  it("returns process-only agents when the database is unavailable", async () => {
+    const agents = await adapter.detectAgents({
+      processes: [{ pid: 100, command: "opencode", cwd: "/repo", tty: "ttys001" }],
+    });
+
+    expect(agents).toEqual([
+      expect.objectContaining({
+        type: "opencode",
+        status: AgentStatus.RUNNING,
+        pid: 100,
+        projectPath: "/repo",
+        sessionId: "pid-100",
+        summary: "OpenCode process running",
+      }),
+    ]);
+  });
+
+  it("maps matching OpenCode sessions to agents", async () => {
+    const now = Date.now();
+    writeDatabase(dbPath, {
+      sessions: [{ id: "sess-001", directory: "/repo", timeCreated: now - 60_000 }],
+      messages: [
+        {
+          id: "msg-user",
+          sessionId: "sess-001",
+          role: "user",
+          timeCreated: now - 50_000,
+          timeUpdated: now - 50_000,
+        },
+        {
+          id: "msg-assistant",
+          sessionId: "sess-001",
+          role: "assistant",
+          timeCreated: now - 30_000,
+          timeUpdated: now - 30_000,
+          completed: now - 20_000,
+        },
+      ],
+      parts: [
+        {
+          messageId: "msg-user",
+          sessionId: "sess-001",
+          type: "text",
+          text: "Refactor this module",
+          timeCreated: now - 50_000,
+        },
+      ],
+    });
+
+    const process: ProcessInfo = { pid: 200, command: "opencode", cwd: "/repo", tty: "ttys002" };
+    const [agent] = await adapter.detectAgents({ processes: [process] });
+
+    expect(agent).toMatchObject({
+      type: "opencode",
+      status: AgentStatus.WAITING,
+      pid: 200,
+      projectPath: "/repo",
+      sessionId: "sess-001",
+      summary: "Refactor this module",
+      sessionFilePath: `${dbPath}::sess-001`,
+    });
+  });
+
+  it("returns conversation messages for encoded OpenCode session refs", () => {
+    writeDatabase(dbPath, {
+      sessions: [{ id: "sess-abc", directory: "/repo", timeCreated: Date.now() }],
+      messages: [
+        {
+          id: "msg-user",
+          sessionId: "sess-abc",
+          role: "user",
+          timeCreated: 1000,
+          timeUpdated: 1000,
+        },
+      ],
+      parts: [
+        {
+          messageId: "msg-user",
+          sessionId: "sess-abc",
+          type: "text",
+          text: "Hello agent",
+          timeCreated: 1000,
+        },
+      ],
+    });
+
+    expect(adapter.getConversation(`${dbPath}::sess-abc`)).toEqual([
+      { role: "user", content: "Hello agent" },
+    ]);
+    expect(adapter.getConversation("/not-an-opencode-ref")).toEqual([]);
+  });
+});
+
+function writeDatabase(
+  filePath: string,
+  data: {
+    sessions: Array<{ id: string; directory: string; timeCreated: number }>;
+    messages?: Array<{
+      id: string;
+      sessionId: string;
+      role: string;
+      timeCreated: number;
+      timeUpdated: number;
+      completed?: number;
+    }>;
+    parts?: Array<{
+      messageId: string;
+      sessionId: string;
+      type: string;
+      text?: string;
+      reasoning?: string;
+      tool?: string;
+      timeCreated: number;
+    }>;
+  },
+): void {
+  const db = new Database(filePath);
+  db.exec(`
+    CREATE TABLE session (id TEXT, directory TEXT, time_created INTEGER);
+    CREATE TABLE message (id TEXT, session_id TEXT, data TEXT, time_created INTEGER, time_updated INTEGER);
+    CREATE TABLE part (message_id TEXT, session_id TEXT, data TEXT, time_created INTEGER);
+  `);
+
+  const insertSession = db.prepare(
+    "INSERT INTO session (id, directory, time_created) VALUES (?, ?, ?)",
+  );
+  for (const session of data.sessions) {
+    insertSession.run(session.id, session.directory, session.timeCreated);
+  }
+
+  const insertMessage = db.prepare(
+    "INSERT INTO message (id, session_id, data, time_created, time_updated) VALUES (?, ?, ?, ?, ?)",
+  );
+  for (const message of data.messages ?? []) {
+    insertMessage.run(
+      message.id,
+      message.sessionId,
+      JSON.stringify({
+        role: message.role,
+        time: message.completed === undefined ? {} : { completed: message.completed },
+      }),
+      message.timeCreated,
+      message.timeUpdated,
+    );
+  }
+
+  const insertPart = db.prepare(
+    "INSERT INTO part (message_id, session_id, data, time_created) VALUES (?, ?, ?, ?)",
+  );
+  for (const part of data.parts ?? []) {
+    insertPart.run(
+      part.messageId,
+      part.sessionId,
+      JSON.stringify({
+        type: part.type,
+        text: part.text,
+        reasoning: part.reasoning,
+        tool: part.tool,
+      }),
+      part.timeCreated,
+    );
+  }
+
+  db.close();
+}

package/src/__tests__/providers/opencode/OpenCodeAgentMapper.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it } from "vitest";
+import { AgentStatus } from "../../../adapters/AgentAdapter.js";
+import { OpenCodeAgentMapper } from "../../../providers/opencode/OpenCodeAgentMapper.js";
+
+describe("OpenCodeAgentMapper", () => {
+  const mapper = new OpenCodeAgentMapper("/tmp/opencode.db");
+
+  it("maps completed assistant sessions as waiting", () => {
+    const now = Date.now();
+
+    const agent = mapper.mapSessionToAgent(
+      { sessionId: "sess-1", directory: "/repo", timeCreated: now - 60_000 },
+      {
+        lastRole: "assistant",
+        lastTimeUpdated: now - 30_000,
+        lastAssistantCompleted: true,
+        lastAssistantErrored: false,
+        summary: "Ship the feature",
+      },
+      { pid: 123, command: "opencode", cwd: "/repo" },
+    );
+
+    expect(agent).toMatchObject({
+      type: "opencode",
+      status: AgentStatus.WAITING,
+      summary: "Ship the feature",
+      pid: 123,
+      projectPath: "/repo",
+      sessionId: "sess-1",
+      sessionFilePath: "/tmp/opencode.db::sess-1",
+    });
+  });
+
+  it("keeps incomplete assistant sessions running even when they are quiet briefly", () => {
+    const now = Date.now();
+
+    const agent = mapper.mapSessionToAgent(
+      { sessionId: "sess-2", directory: "/repo", timeCreated: now - 120_000 },
+      {
+        lastRole: "assistant",
+        lastTimeUpdated: now - 120_000,
+        lastAssistantCompleted: false,
+        lastAssistantErrored: false,
+        summary: "",
+      },
+      { pid: 124, command: "opencode", cwd: "/repo" },
+    );
+
+    expect(agent.status).toBe(AgentStatus.RUNNING);
+    expect(agent.summary).toBe("OpenCode session active");
+  });
+
+  it("marks stale sessions idle", () => {
+    const staleTime = Date.now() - 10 * 60 * 1000;
+
+    const agent = mapper.mapSessionToAgent(
+      { sessionId: "sess-3", directory: "/old", timeCreated: staleTime },
+      {
+        lastRole: "assistant",
+        lastTimeUpdated: staleTime,
+        lastAssistantCompleted: true,
+        lastAssistantErrored: false,
+        summary: "",
+      },
+      { pid: 125, command: "opencode", cwd: "/old" },
+    );
+
+    expect(agent.status).toBe(AgentStatus.IDLE);
+  });
+
+  it("maps unmatched processes as running process-only agents", () => {
+    const agent = mapper.mapProcessOnlyAgent({ pid: 500, command: "opencode", cwd: "/repo" });
+
+    expect(agent).toMatchObject({
+      type: "opencode",
+      status: AgentStatus.RUNNING,
+      summary: "OpenCode process running",
+      pid: 500,
+      projectPath: "/repo",
+      sessionId: "pid-500",
+    });
+  });
+});

package/src/__tests__/providers/opencode/OpenCodeSessionLocator.test.ts

@@ -0,0 +1,84 @@
+import Database from "better-sqlite3";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { OpenCodeSessionLocator } from "../../../providers/opencode/OpenCodeSessionLocator.js";
+import { OpenCodeSessionParser } from "../../../providers/opencode/OpenCodeSessionParser.js";
+
+describe("OpenCodeSessionLocator", () => {
+  let tmpDir: string;
+  let dbPath: string;
+  let locator: OpenCodeSessionLocator;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "opencode-locator-test-"));
+    dbPath = path.join(tmpDir, "opencode.db");
+    locator = new OpenCodeSessionLocator(dbPath, new OpenCodeSessionParser());
+  });
+
+  afterEach(() => {
+    locator.close();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("returns null when the database file does not exist", () => {
+    expect(locator.openDb()).toBeNull();
+    expect(locator.listSessions()).toEqual([]);
+  });
+
+  it("finds the newest session for a directory", () => {
+    writeDatabase(dbPath, [
+      { id: "old", directory: "/repo", timeCreated: 1000 },
+      { id: "new", directory: "/repo", timeCreated: 2000 },
+      { id: "other", directory: "/other", timeCreated: 3000 },
+    ]);
+
+    const db = locator.openDb();
+    expect(db).not.toBeNull();
+    expect(locator.findSessionForDirectory(db!, "/repo")).toEqual({
+      sessionId: "new",
+      directory: "/repo",
+      timeCreated: 2000,
+    });
+  });
+
+  it("lists sessions and filters by cwd", () => {
+    writeDatabase(dbPath, [
+      { id: "sess-a", directory: "/repo-a", timeCreated: 1000 },
+      { id: "sess-b", directory: "/repo-b", timeCreated: 2000 },
+    ]);
+
+    const sessions = locator.listSessions({ cwd: "/repo-a" });
+
+    expect(sessions).toEqual([
+      expect.objectContaining({
+        type: "opencode",
+        sessionId: "sess-a",
+        cwd: "/repo-a",
+        sessionFilePath: `${dbPath}::sess-a`,
+      }),
+    ]);
+  });
+});
+
+function writeDatabase(
+  filePath: string,
+  sessions: Array<{ id: string; directory: string; timeCreated: number }>,
+): void {
+  const db = new Database(filePath);
+  db.exec(`
+    CREATE TABLE session (id TEXT, directory TEXT, time_created INTEGER);
+    CREATE TABLE message (id TEXT, session_id TEXT, data TEXT, time_created INTEGER, time_updated INTEGER);
+    CREATE TABLE part (message_id TEXT, session_id TEXT, data TEXT, time_created INTEGER);
+  `);
+
+  const insertSession = db.prepare(
+    "INSERT INTO session (id, directory, time_created) VALUES (?, ?, ?)",
+  );
+  for (const session of sessions) {
+    insertSession.run(session.id, session.directory, session.timeCreated);
+  }
+
+  db.close();
+}

package/src/__tests__/providers/opencode/OpenCodeSessionParser.test.ts

@@ -0,0 +1,148 @@
+import Database from "better-sqlite3";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { OpenCodeSessionParser } from "../../../providers/opencode/OpenCodeSessionParser.js";
+
+describe("OpenCodeSessionParser", () => {
+  let db: Database.Database;
+  let parser: OpenCodeSessionParser;
+
+  beforeEach(() => {
+    db = new Database(":memory:");
+    db.exec(`
+      CREATE TABLE message (id TEXT, session_id TEXT, data TEXT, time_created INTEGER, time_updated INTEGER);
+      CREATE TABLE part (message_id TEXT, session_id TEXT, data TEXT, time_created INTEGER);
+    `);
+    parser = new OpenCodeSessionParser();
+  });
+
+  afterEach(() => {
+    db.close();
+  });
+
+  it("extracts session stats from OpenCode messages and parts", () => {
+    insertMessage(db, {
+      id: "msg-user",
+      sessionId: "sess-1",
+      role: "user",
+      timeCreated: 1000,
+      timeUpdated: 1000,
+    });
+    insertMessage(db, {
+      id: "msg-assistant",
+      sessionId: "sess-1",
+      role: "assistant",
+      timeCreated: 2000,
+      timeUpdated: 2500,
+      completed: 2400,
+    });
+    insertPart(db, {
+      messageId: "msg-user",
+      sessionId: "sess-1",
+      data: { type: "text", text: "Plan the migration" },
+      timeCreated: 1000,
+    });
+
+    expect(parser.getSessionStats(db, "sess-1")).toEqual({
+      lastRole: "assistant",
+      lastTimeUpdated: 2500,
+      lastAssistantCompleted: true,
+      lastAssistantErrored: false,
+      summary: "Plan the migration",
+    });
+  });
+
+  it("orders stats by message creation time, not metadata update time", () => {
+    insertMessage(db, {
+      id: "msg-user",
+      sessionId: "sess-1",
+      role: "user",
+      timeCreated: 1000,
+      timeUpdated: 3000,
+    });
+    insertMessage(db, {
+      id: "msg-assistant",
+      sessionId: "sess-1",
+      role: "assistant",
+      timeCreated: 2000,
+      timeUpdated: 2100,
+      completed: 2200,
+    });
+
+    expect(parser.getSessionStats(db, "sess-1").lastRole).toBe("assistant");
+  });
+
+  it("reads visible conversation text and hides verbose-only parts by default", () => {
+    insertMessage(db, {
+      id: "msg-user",
+      sessionId: "sess-1",
+      role: "user",
+      timeCreated: 1000,
+      timeUpdated: 1000,
+    });
+    insertMessage(db, {
+      id: "msg-assistant",
+      sessionId: "sess-1",
+      role: "assistant",
+      timeCreated: 2000,
+      timeUpdated: 2000,
+    });
+    insertPart(db, {
+      messageId: "msg-user",
+      sessionId: "sess-1",
+      data: { type: "text", text: "Hello" },
+      timeCreated: 1000,
+    });
+    insertPart(db, {
+      messageId: "msg-assistant",
+      sessionId: "sess-1",
+      data: { type: "reasoning", reasoning: "private thought" },
+      timeCreated: 2000,
+    });
+    insertPart(db, {
+      messageId: "msg-assistant",
+      sessionId: "sess-1",
+      data: { type: "tool", tool: "read_file" },
+      timeCreated: 3000,
+    });
+
+    expect(parser.getConversation(db, "sess-1")).toEqual([{ role: "user", content: "Hello" }]);
+    expect(parser.getConversation(db, "sess-1", { verbose: true })).toEqual([
+      { role: "user", content: "Hello" },
+      { role: "assistant", content: "[thinking] private thought" },
+      { role: "assistant", content: "[tool: read_file]" },
+    ]);
+  });
+});
+
+function insertMessage(
+  db: Database.Database,
+  input: {
+    id: string;
+    sessionId: string;
+    role: string;
+    timeCreated: number;
+    timeUpdated: number;
+    completed?: number;
+  },
+): void {
+  db.prepare(
+    "INSERT INTO message (id, session_id, data, time_created, time_updated) VALUES (?, ?, ?, ?, ?)",
+  ).run(
+    input.id,
+    input.sessionId,
+    JSON.stringify({
+      role: input.role,
+      time: input.completed === undefined ? {} : { completed: input.completed },
+    }),
+    input.timeCreated,
+    input.timeUpdated,
+  );
+}
+
+function insertPart(
+  db: Database.Database,
+  input: { messageId: string; sessionId: string; data: unknown; timeCreated: number },
+): void {
+  db.prepare("INSERT INTO part (message_id, session_id, data, time_created) VALUES (?, ?, ?, ?)")
+    .run(input.messageId, input.sessionId, JSON.stringify(input.data), input.timeCreated);
+}

package/src/__tests__/runtime/HerdrAgentDiscovery.test.ts

@@ -0,0 +1,131 @@
+import {
+  extractHerdrAgentPanes,
+  fetchHerdrAgentPanes,
+  findMatchingHerdrPane,
+} from "../../runtime/herdr/HerdrAgentDiscovery.js";
+import type { HerdrCommandRunner } from "../../runtime/herdr/HerdrCliClient.js";
+
+function jsonResponse(value: unknown): { stdout: string; stderr: string } {
+  return { stdout: JSON.stringify(value), stderr: "" };
+}
+
+describe("HerdrAgentDiscovery", () => {
+  it("extracts agent panes from pane list responses", () => {
+    const panes = extractHerdrAgentPanes({
+      result: {
+        panes: [
+          {
+            agent: "codex",
+            agent_session: { value: "session-1" },
+            cwd: "/repo",
+            pane_id: "w32:p1",
+            workspace_id: "w32",
+            tab_id: "w32:t1",
+          },
+        ],
+      },
+    });
+
+    expect(panes).toEqual([
+      {
+        agent: "codex",
+        agentSessionId: "session-1",
+        cwd: "/repo",
+        paneId: "w32:p1",
+        workspaceId: "w32",
+        tabId: "w32:t1",
+      },
+    ]);
+  });
+
+  it("matches by foreground PID before falling back to ambiguous cwd and type", () => {
+    const pane = findMatchingHerdrPane(
+      {
+        type: "codex",
+        projectPath: "/repo",
+        sessionId: "pid-64904",
+        pid: 64904,
+      },
+      [
+        { agent: "codex", cwd: "/repo", paneId: "w31:p1", foregroundPids: [44290] },
+        { agent: "codex", cwd: "/repo", paneId: "w32:p1", foregroundPids: [64904] },
+      ],
+    );
+
+    expect(pane?.paneId).toBe("w32:p1");
+  });
+
+  it("prefers a foreground PID match over a shell PID match", () => {
+    const pane = findMatchingHerdrPane(
+      {
+        type: "codex",
+        projectPath: "/repo",
+        sessionId: "pid-64904",
+        pid: 64904,
+      },
+      [
+        { agent: "codex", cwd: "/repo", paneId: "w31:p1", shellPid: 64904 },
+        { agent: "codex", cwd: "/repo", paneId: "w32:p1", foregroundPids: [64904] },
+      ],
+    );
+
+    expect(pane?.paneId).toBe("w32:p1");
+  });
+
+  it("enriches pane list output with foreground process IDs", async () => {
+    const runner = vi
+      .fn<HerdrCommandRunner>()
+      .mockResolvedValueOnce(
+        jsonResponse({
+          result: {
+            panes: [
+              { agent: "codex", cwd: "/repo", pane_id: "w31:p1" },
+              { agent: "codex", cwd: "/repo", pane_id: "w32:p1" },
+            ],
+          },
+        }),
+      )
+      .mockResolvedValueOnce(
+        jsonResponse({
+          result: {
+            process_info: {
+              pane_id: "w31:p1",
+              shell_pid: 111,
+              foreground_processes: [{ pid: 44290 }],
+            },
+          },
+        }),
+      )
+      .mockResolvedValueOnce(
+        jsonResponse({
+          result: {
+            process_info: {
+              pane_id: "w32:p1",
+              shell_pid: 222,
+              foreground_processes: [{ pid: 64904 }],
+            },
+          },
+        }),
+      );
+
+    const panes = await fetchHerdrAgentPanes(runner);
+
+    expect(runner).toHaveBeenNthCalledWith(1, "herdr", ["pane", "list"]);
+    expect(runner).toHaveBeenNthCalledWith(2, "herdr", [
+      "pane",
+      "process-info",
+      "--pane",
+      "w31:p1",
+    ]);
+    expect(runner).toHaveBeenNthCalledWith(3, "herdr", [
+      "pane",
+      "process-info",
+      "--pane",
+      "w32:p1",
+    ]);
+    expect(panes).toMatchObject([
+      { paneId: "w31:p1", foregroundPids: [44290], shellPid: 111 },
+      { paneId: "w32:p1", foregroundPids: [64904], shellPid: 222 },
+    ]);
+  });
+});

package/src/__tests__/runtime/HerdrAgentRuntime.test.ts

@@ -186,11 +186,30 @@ describe("HerdrAgentRuntime", () => {
       agentResponse(),
       processInfoResponse({ shellPid: 12000 }),
     ]);
-    const runtime = new HerdrAgentRuntime({ runner, env: {} });
+    const runtime = new HerdrAgentRuntime({ runner, env: {}, processInfoPollMs: 0 });
 
     await expect(runtime.startAgent(startInput)).resolves.toMatchObject({ pid: 12000 });
   });
 
+  it("waits for a foreground process pid before falling back to the pane shell pid", async () => {
+    const runner = createRunner([
+      workspaceResponse(),
+      agentResponse(),
+      processInfoResponse({ shellPid: 12000 }),
+      processInfoResponse({ shellPid: 12000, pid: 12345, processName: "node" }),
+    ]);
+    const runtime = new HerdrAgentRuntime({
+      runner,
+      env: {},
+      processInfoPollMs: 100,
+      processInfoPollIntervalMs: 0,
+    });
+
+    await expect(runtime.startAgent(startInput)).resolves.toMatchObject({ pid: 12345 });
+    expect(runner).toHaveBeenNthCalledWith(3, "herdr", ["pane", "process-info", "--pane", "w1:p1"]);
+    expect(runner).toHaveBeenNthCalledWith(4, "herdr", ["pane", "process-info", "--pane", "w1:p1"]);
+  });
+
   it("passes only explicit extra agent args after the Herdr start separator", async () => {
     const runner = createRunner([
       workspaceResponse(),