@ai-devkit/agent-manager 0.34.0 → 0.36.0

package/src/__tests__/adapters/KiroAdapter.test.ts

@@ -0,0 +1,534 @@
+/**
+ * Tests for KiroAdapter
+ */
+
+import type { MockedFunction } from "vitest";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+import { KiroAdapter } from "../../adapters/KiroAdapter.js";
+import type { ProcessInfo } from "../../adapters/AgentAdapter.js";
+import { AgentStatus } from "../../adapters/AgentAdapter.js";
+import {
+  listAgentProcesses,
+  enrichProcesses,
+  captureProcessSnapshot,
+} from "../../utils/process.js";
+import { generateAgentName } from "../../utils/matching.js";
+
+vi.mock("../../utils/process.js", async (importOriginal) => {
+  const actual = (await importOriginal()) as typeof import("../../utils/process.js");
+  return {
+    ...actual,
+    listAgentProcesses: vi.fn(),
+    enrichProcesses: vi.fn(),
+    captureProcessSnapshot: vi.fn(),
+  };
+});
+
+vi.mock("../../utils/matching.js", async (importOriginal) => {
+  const actual = (await importOriginal()) as typeof import("../../utils/matching.js");
+  return {
+    ...actual,
+    generateAgentName: vi.fn(),
+  };
+});
+
+const mockedListAgentProcesses = listAgentProcesses as MockedFunction<typeof listAgentProcesses>;
+const mockedEnrichProcesses = enrichProcesses as MockedFunction<typeof enrichProcesses>;
+const mockedCaptureProcessSnapshot = captureProcessSnapshot as MockedFunction<
+  typeof captureProcessSnapshot
+>;
+const mockedGenerateAgentName = generateAgentName as MockedFunction<typeof generateAgentName>;
+
+describe("KiroAdapter", () => {
+  let adapter: KiroAdapter;
+  let tmpHome: string;
+  let sessionsDir: string;
+
+  beforeEach(() => {
+    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "kiro-adapter-test-"));
+    process.env.HOME = tmpHome;
+    sessionsDir = path.join(tmpHome, ".kiro", "sessions", "cli");
+    fs.mkdirSync(sessionsDir, { recursive: true });
+
+    adapter = new KiroAdapter();
+
+    mockedListAgentProcesses.mockReset();
+    mockedEnrichProcesses.mockReset();
+    mockedCaptureProcessSnapshot.mockReset();
+    mockedGenerateAgentName.mockReset();
+
+    mockedEnrichProcesses.mockImplementation((procs) => procs);
+    // Compatibility shim for standalone adapter discovery; the manager captures once and slices by name.
+    mockedCaptureProcessSnapshot.mockImplementation(async (names) =>
+      enrichProcesses(names.flatMap((name) => listAgentProcesses(name))),
+    );
+    mockedGenerateAgentName.mockImplementation((cwd: string, pid: number) => {
+      const folder = path.basename(cwd) || "unknown";
+      return `${folder} (${pid})`;
+    });
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpHome, { recursive: true, force: true });
+  });
+
+  describe("initialization", () => {
+    it("exposes the kiro type and process names", () => {
+      expect(adapter.type).toBe("kiro");
+      expect(adapter.processNames).toEqual(["kiro-cli", "kiro", "kiro-cli-chat", "node"]);
+    });
+  });
+
+  describe("canHandle", () => {
+    it("identifies Kiro commands without matching unrelated paths", () => {
+      expect(adapter.canHandle({ pid: 1, command: "kiro-cli", cwd: "/repo", tty: "ttys001" })).toBe(
+        true,
+      );
+      expect(
+        adapter.canHandle({
+          pid: 2,
+          command: "/usr/local/bin/kiro --model x",
+          cwd: "/repo",
+          tty: "ttys002",
+        }),
+      ).toBe(true);
+      expect(
+        adapter.canHandle({
+          pid: 3,
+          command: "node /opt/kiro/bin/kiro-cli.js",
+          cwd: "/repo",
+          tty: "ttys003",
+        }),
+      ).toBe(true);
+      expect(
+        adapter.canHandle({
+          pid: 4,
+          command: "node /repo/feature-kiro-adapter/script.js",
+          cwd: "/repo",
+          tty: "ttys004",
+        }),
+      ).toBe(false);
+      expect(
+        adapter.canHandle({
+          pid: 5,
+          command: "kiro-cli chat",
+          cwd: "/repo",
+          tty: "ttys005",
+        }),
+      ).toBe(true);
+      expect(
+        adapter.canHandle({
+          pid: 6,
+          command: "bun /opt/kiro/bin/kiro-cli.js",
+          cwd: "/repo",
+          tty: "ttys006",
+        }),
+      ).toBe(true);
+      expect(
+        adapter.canHandle({
+          pid: 7,
+          command: "node /usr/local/bin/ai-devkit agent start --type kiro",
+          cwd: "/repo",
+          tty: "ttys007",
+        }),
+      ).toBe(false);
+      expect(
+        adapter.canHandle({
+          pid: 8,
+          command: "node server.js --name kiro",
+          cwd: "/repo",
+          tty: "ttys008",
+        }),
+      ).toBe(false);
+      expect(
+        adapter.canHandle({
+          pid: 9,
+          command: "kiro-cli-chat acp",
+          cwd: "/repo",
+          tty: "ttys009",
+        }),
+      ).toBe(false);
+    });
+  });
+
+  describe("detectAgents", () => {
+    it("returns [] when there are no Kiro processes", async () => {
+      mockedListAgentProcesses.mockReturnValue([]);
+      expect(await adapter.detectAgents()).toEqual([]);
+    });
+
+    it("maps a running Kiro process through its session lock and metadata", async () => {
+      const cwd = "/repo/project-a";
+      const proc = makeProcess({ pid: 101, cwd: "/process/cwd" });
+      const updatedAt = new Date().toISOString();
+      const sessionFile = writeKiroSession(
+        "sess-101",
+        cwd,
+        [prompt("implement Kiro adapter", 1781098057), assistantText("working on it")],
+        101,
+        updatedAt,
+      );
+      mockedCaptureProcessSnapshot.mockResolvedValue([proc]);
+
+      const agents = await adapter.detectAgents();
+
+      expect(agents).toHaveLength(1);
+      expect(agents[0]).toMatchObject({
+        type: "kiro",
+        pid: 101,
+        projectPath: cwd,
+        sessionId: "sess-101",
+        summary: "implement Kiro adapter",
+        status: AgentStatus.WAITING,
+        sessionFilePath: sessionFile,
+        lastActive: new Date(updatedAt),
+      });
+    });
+
+    it("matches a lock held by a kiro-cli-chat acp descendant when bun is not collected", async () => {
+      const cwd = "/repo/project-a";
+      const sessionFile = writeKiroSession(
+        "sess-acp",
+        cwd,
+        [prompt("implement Kiro adapter", 1781098057), assistantText("working on it")],
+        55236,
+      );
+      const kiro = makeProcess({ pid: 55111, command: "kiro-cli", cwd: "/process/cwd", ppid: 1 });
+      const chat = makeProcess({
+        pid: 55168,
+        command: "kiro-cli-chat chat",
+        ppid: 55111,
+        tty: "ttys001",
+      });
+      const acp = makeProcess({
+        pid: 55236,
+        command: "kiro-cli-chat acp",
+        ppid: 55198,
+        tty: "ttys001",
+      });
+      mockedCaptureProcessSnapshot.mockResolvedValue([kiro, chat, acp]);
+
+      const agents = await adapter.detectAgents();
+
+      expect(agents).toEqual([
+        expect.objectContaining({
+          type: "kiro",
+          pid: 55111,
+          projectPath: cwd,
+          sessionId: "sess-acp",
+          summary: "implement Kiro adapter",
+          sessionFilePath: sessionFile,
+        }),
+      ]);
+    });
+
+    it("walks a collected kiro-cli-chat parent chain to the owning kiro-cli", async () => {
+      const sessionFile = writeKiroSession(
+        "sess-owner",
+        "/repo/owner",
+        [prompt("owned session", 1781098057)],
+        55236,
+      );
+      const owner = makeProcess({ pid: 55111, command: "kiro-cli", cwd: "/repo/owner", ppid: 1 });
+      const other = makeProcess({ pid: 66111, command: "kiro-cli", cwd: "/repo/other", ppid: 1 });
+      const chat = makeProcess({ pid: 55168, command: "kiro-cli-chat chat", ppid: 55111 });
+      const acp = makeProcess({ pid: 55236, command: "kiro-cli-chat acp", ppid: 55168 });
+      mockedCaptureProcessSnapshot.mockResolvedValue([owner, other, chat, acp]);
+
+      const agents = await adapter.detectAgents();
+
+      expect(agents).toEqual([
+        expect.objectContaining({
+          pid: 55111,
+          projectPath: "/repo/owner",
+          sessionId: "sess-owner",
+          sessionFilePath: sessionFile,
+        }),
+        expect.objectContaining({ pid: 66111, sessionId: "pid-66111" }),
+      ]);
+    });
+
+    it("does not attach a session through tty ?? or an ambiguous tty", async () => {
+      writeKiroSession("sess-unknown-tty", "/repo/unknown", [prompt("hello", 1781098057)], 55236);
+      const unknownTty = makeProcess({ pid: 55111, command: "kiro-cli", tty: "??", ppid: 1 });
+      const unknownAcp = makeProcess({
+        pid: 55236,
+        command: "kiro-cli-chat acp",
+        tty: "??",
+        ppid: 55198,
+      });
+      mockedCaptureProcessSnapshot.mockResolvedValue([unknownTty, unknownAcp]);
+
+      expect(await adapter.detectAgents()).toEqual([
+        expect.objectContaining({ pid: 55111, sessionId: "pid-55111" }),
+      ]);
+
+      writeKiroSession("sess-shared-tty", "/repo/shared", [prompt("hello", 1781098057)], 66236);
+      const first = makeProcess({ pid: 55111, command: "kiro-cli", tty: "ttys001", ppid: 1 });
+      const second = makeProcess({ pid: 66111, command: "kiro-cli", tty: "ttys001", ppid: 1 });
+      const sharedAcp = makeProcess({
+        pid: 66236,
+        command: "kiro-cli-chat acp",
+        tty: "ttys001",
+        ppid: 55198,
+      });
+      mockedCaptureProcessSnapshot.mockResolvedValue([first, second, sharedAcp]);
+
+      expect(await adapter.detectAgents()).toEqual([
+        expect.objectContaining({ pid: 55111, sessionId: "pid-55111" }),
+        expect.objectContaining({ pid: 66111, sessionId: "pid-66111" }),
+      ]);
+    });
+
+    it("uses a supplied process snapshot instead of scanning again", async () => {
+      const proc = makeProcess({ pid: 606, cwd: "/repo/context" });
+      mockedCaptureProcessSnapshot.mockResolvedValue([makeProcess({ pid: 999 })]);
+
+      const agents = await adapter.detectAgents({ processes: [proc] });
+
+      expect(mockedCaptureProcessSnapshot).not.toHaveBeenCalled();
+      expect(agents).toEqual([
+        expect.objectContaining({
+          pid: 606,
+          projectPath: "/repo/context",
+          sessionId: "pid-606",
+        }),
+      ]);
+    });
+
+    it("uses only a lock whose PID belongs to a running Kiro process", async () => {
+      writeKiroSession("ended-session", "/repo/ended", [prompt("old conversation", 1781098057)]);
+      writeKiroSession(
+        "other-process",
+        "/repo/other",
+        [prompt("other conversation", 1781098057)],
+        999,
+      );
+      const proc = makeProcess({ pid: 202, cwd: "/repo/current" });
+      mockedCaptureProcessSnapshot.mockResolvedValue([proc]);
+
+      const agents = await adapter.detectAgents();
+
+      expect(agents).toEqual([
+        expect.objectContaining({
+          pid: 202,
+          projectPath: "/repo/current",
+          sessionId: "pid-202",
+          summary: "Kiro process running",
+        }),
+      ]);
+    });
+
+    it("ignores malformed lock files", async () => {
+      writeKiroSession("bad-lock", "/repo/project", [prompt("hello", 1781098057)]);
+      fs.writeFileSync(path.join(sessionsDir, "bad-lock.lock"), "{bad json");
+      const proc = makeProcess({ pid: 303, cwd: "/repo/project" });
+      mockedCaptureProcessSnapshot.mockResolvedValue([proc]);
+
+      const agents = await adapter.detectAgents();
+
+      expect(agents[0]).toMatchObject({ sessionId: "pid-303" });
+    });
+
+    it("reports running while the latest assistant event invokes a tool", async () => {
+      writeKiroSession(
+        "tool-session",
+        "/repo/project",
+        [
+          prompt("inspect the file", Math.floor(Date.now() / 1000)),
+          assistantTool("fs_read", { path: "/repo/project/file.ts" }),
+        ],
+        404,
+        new Date().toISOString(),
+      );
+      const proc = makeProcess({ pid: 404, cwd: "/repo/project" });
+      mockedCaptureProcessSnapshot.mockResolvedValue([proc]);
+
+      const agents = await adapter.detectAgents();
+
+      expect(agents[0].status).toBe(AgentStatus.RUNNING);
+    });
+
+    it("returns a process-only agent when the locked transcript is missing", async () => {
+      fs.writeFileSync(path.join(sessionsDir, "missing.lock"), JSON.stringify({ pid: 505 }));
+      const proc = makeProcess({ pid: 505, cwd: "/repo/project-e" });
+      mockedCaptureProcessSnapshot.mockResolvedValue([proc]);
+
+      const agents = await adapter.detectAgents();
+
+      expect(agents).toEqual([
+        expect.objectContaining({
+          type: "kiro",
+          status: AgentStatus.RUNNING,
+          pid: 505,
+          projectPath: "/repo/project-e",
+          sessionId: "pid-505",
+          summary: "Kiro process running",
+        }),
+      ]);
+    });
+  });
+
+  describe("getConversation", () => {
+    it("reads real Kiro prompt and assistant message envelopes", () => {
+      const sessionFile = writeKiroSession("conversation", "/repo/project-f", [
+        prompt("hello kiro", 1781098057),
+        assistantText("Hello! How can I help?"),
+        "{not json",
+      ]);
+
+      expect(adapter.getConversation(sessionFile)).toEqual([
+        { role: "user", content: "hello kiro", timestamp: "2026-06-10T13:27:37.000Z" },
+        { role: "assistant", content: "Hello! How can I help?", timestamp: undefined },
+      ]);
+    });
+
+    it("includes Kiro tool use and results only in verbose conversation mode", () => {
+      const sessionFile = writeKiroSession("tools", "/repo/project-tools", [
+        prompt("read package.json", 1781098057),
+        assistantTool("fs_read", { path: "package.json" }),
+        toolResult("contents", "success"),
+        assistantText("Done."),
+      ]);
+
+      expect(adapter.getConversation(sessionFile)).toEqual([
+        { role: "user", content: "read package.json", timestamp: "2026-06-10T13:27:37.000Z" },
+        { role: "assistant", content: "Done.", timestamp: undefined },
+      ]);
+      expect(adapter.getConversation(sessionFile, { verbose: true })).toEqual([
+        { role: "user", content: "read package.json", timestamp: "2026-06-10T13:27:37.000Z" },
+        {
+          role: "assistant",
+          content: '[Tool: fs_read] {"path":"package.json"}',
+          timestamp: undefined,
+        },
+        { role: "system", content: "[Tool Result] contents", timestamp: undefined },
+        { role: "assistant", content: "Done.", timestamp: undefined },
+      ]);
+    });
+  });
+
+  describe("listSessions", () => {
+    it("lists historical sessions using metadata and applies cwd filtering", async () => {
+      const matchingCwd = "/repo/project-g";
+      const matchingSession = writeKiroSession("sess-g", matchingCwd, [
+        prompt("first matching message", 1781098057),
+        assistantText("response"),
+      ]);
+      writeKiroSession("sess-h", "/repo/project-h", [prompt("other message", 1781098057)]);
+
+      const sessions = await adapter.listSessions({ cwd: matchingCwd });
+
+      expect(sessions).toEqual([
+        expect.objectContaining({
+          type: "kiro",
+          sessionId: "sess-g",
+          cwd: matchingCwd,
+          firstUserMessage: "first matching message",
+          startedAt: new Date("2026-06-10T13:27:17.000Z"),
+          lastActive: new Date("2026-06-10T13:27:40.000Z"),
+          sessionFilePath: matchingSession,
+        }),
+      ]);
+    });
+  });
+
+  function makeProcess(overrides: Partial<ProcessInfo>): ProcessInfo {
+    return {
+      pid: 1,
+      command: "kiro-cli chat",
+      cwd: "/repo",
+      tty: "ttys001",
+      startTime: new Date("2026-06-10T13:27:17.000Z"),
+      ...overrides,
+    };
+  }
+
+  function writeKiroSession(
+    sessionId: string,
+    cwd: string,
+    entries: Array<Record<string, unknown> | string>,
+    pid?: number,
+    updatedAt = "2026-06-10T13:27:40.000Z",
+  ): string {
+    fs.writeFileSync(
+      path.join(sessionsDir, `${sessionId}.json`),
+      JSON.stringify({
+        session_id: sessionId,
+        cwd,
+        created_at: "2026-06-10T13:27:17.000Z",
+        updated_at: updatedAt,
+        title: "Session title",
+      }),
+    );
+    const filePath = path.join(sessionsDir, `${sessionId}.jsonl`);
+    fs.writeFileSync(
+      filePath,
+      entries
+        .map((entry) => (typeof entry === "string" ? entry : JSON.stringify(entry)))
+        .join("\n"),
+    );
+    if (pid !== undefined) {
+      fs.writeFileSync(
+        path.join(sessionsDir, `${sessionId}.lock`),
+        JSON.stringify({
+          pid,
+          started_at: "2026-06-10T13:27:17.000Z",
+        }),
+      );
+    }
+    return filePath;
+  }
+
+  function prompt(text: string, timestamp: number): Record<string, unknown> {
+    return {
+      version: "v1",
+      kind: "Prompt",
+      data: {
+        content: [{ kind: "text", data: text }],
+        meta: { timestamp },
+      },
+    };
+  }
+
+  function assistantText(text: string): Record<string, unknown> {
+    return {
+      version: "v1",
+      kind: "AssistantMessage",
+      data: { content: [{ kind: "text", data: text }] },
+    };
+  }
+
+  function assistantTool(name: string, input: Record<string, unknown>): Record<string, unknown> {
+    return {
+      version: "v1",
+      kind: "AssistantMessage",
+      data: {
+        content: [
+          {
+            kind: "toolUse",
+            data: { toolUseId: "tool-1", name, input },
+          },
+        ],
+      },
+    };
+  }
+
+  function toolResult(result: string, status: string): Record<string, unknown> {
+    return {
+      version: "v1",
+      kind: "ToolResults",
+      data: {
+        content: [
+          {
+            kind: "toolResult",
+            data: { toolUseId: "tool-1", status, result },
+          },
+        ],
+      },
+    };
+  }
+});