@ai-devkit/agent-manager 0.34.0 → 0.36.0

package/src/__tests__/providers/gemini/GeminiCliAdapter.test.ts

@@ -1185,6 +1185,27 @@ describe("GeminiCliAdapter", () => {
       });
     });
 
+    it("finds an exact session ID from Gemini metadata", async () => {
+      const wantedPath = writeSession(tmpHome, "aaa", "session-one", {
+        sessionId: "wanted",
+        projectHash: hashProjectRoot("/repo"),
+        startTime: "2025-01-01T00:00:00Z",
+        directories: ["/repo"],
+        messages: [{ type: "user", content: "wanted prompt" }],
+      });
+      writeSession(tmpHome, "bbb", "session-two", {
+        sessionId: "other",
+        projectHash: hashProjectRoot("/other"),
+        startTime: "2025-01-01T00:00:00Z",
+        directories: ["/other"],
+        messages: [{ type: "user", content: "other prompt" }],
+      });
+
+      await expect(adapter.findSessionsById("wanted")).resolves.toEqual([
+        expect.objectContaining({ sessionId: "wanted", sessionFilePath: wantedPath }),
+      ]);
+    });
+
     it("applies strict-equality cwd filter against directories[0]", async () => {
       writeSession(tmpHome, "aaa", "session-keep", {
         sessionId: "keep",

package/src/__tests__/providers/grok/GrokAgentMapper.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from "vitest";
+
+import { AgentStatus, type ProcessInfo } from "../../../adapters/AgentAdapter.js";
+import { GrokAgentMapper } from "../../../providers/grok/GrokAgentMapper.js";
+import type { GrokSession } from "../../../providers/grok/GrokSessionParser.js";
+
+function makeProcess(overrides: Partial<ProcessInfo> = {}): ProcessInfo {
+  return { pid: 123, command: "grok", cwd: "/repo/my-app", tty: "ttys001", ...overrides };
+}
+
+function makeSession(overrides: Partial<GrokSession> = {}): GrokSession {
+  return {
+    sessionId: "session-1",
+    projectPath: "/repo/my-app",
+    sessionFilePath: "/home/.grok/sessions/%2Frepo%2Fmy-app/session-1/chat_history.jsonl",
+    sessionStart: new Date(),
+    lastActive: new Date(),
+    lastUserMessage: "Review this change",
+    lastRole: "assistant",
+    ...overrides,
+  };
+}
+
+describe("GrokAgentMapper", () => {
+  const mapper = new GrokAgentMapper();
+
+  it("maps a session to a grok_cli agent pointing at chat_history.jsonl", () => {
+    const agent = mapper.mapSessionToAgent({
+      session: makeSession(),
+      processInfo: makeProcess(),
+    });
+
+    expect(agent).toMatchObject({
+      name: "my-app-123",
+      type: "grok_cli",
+      status: AgentStatus.WAITING,
+      summary: "Review this change",
+      pid: 123,
+      projectPath: "/repo/my-app",
+      sessionId: "session-1",
+      sessionFilePath: "/home/.grok/sessions/%2Frepo%2Fmy-app/session-1/chat_history.jsonl",
+    });
+  });
+
+  it("maps a process-only agent as RUNNING with a pid session id", () => {
+    const agent = mapper.mapProcessOnlyAgent(makeProcess(), "/repo/resolved");
+
+    expect(agent).toMatchObject({
+      type: "grok_cli",
+      status: AgentStatus.RUNNING,
+      summary: "Grok CLI process running",
+      projectPath: "/repo/resolved",
+      sessionId: "pid-123",
+    });
+    expect(agent.sessionFilePath).toBeUndefined();
+  });
+});

package/src/__tests__/{adapters → providers/grok}/GrokCliAdapter.test.ts

@@ -10,18 +10,18 @@ import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
 
-import { GrokCliAdapter } from "../../adapters/GrokCliAdapter.js";
-import type { ProcessInfo } from "../../adapters/AgentAdapter.js";
-import { AgentStatus } from "../../adapters/AgentAdapter.js";
+import { GrokCliAdapter } from "../../../providers/grok/GrokCliAdapter.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";
+} 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");
+vi.mock("../../../utils/process.js", async (importOriginal) => {
+  const actual = (await importOriginal()) as typeof import("../../../utils/process.js");
   return {
     ...actual,
     listAgentProcesses: vi.fn(),
@@ -30,8 +30,8 @@ vi.mock("../../utils/process.js", async (importOriginal) => {
   };
 });
 
-vi.mock("../../utils/matching.js", async (importOriginal) => {
-  const actual = (await importOriginal()) as typeof import("../../utils/matching.js");
+vi.mock("../../../utils/matching.js", async (importOriginal) => {
+  const actual = (await importOriginal()) as typeof import("../../../utils/matching.js");
   return {
     ...actual,
     generateAgentName: vi.fn(),
@@ -335,6 +335,15 @@ describe("GrokCliAdapter", () => {
       );
     });
 
+    it("finds an exact session ID across project groups", async () => {
+      writeSession({});
+      writeSession({ sessionCwd: "/Users/dev/other", id: "other-session" });
+
+      await expect(adapter.findSessionsById(SESSION_ID)).resolves.toEqual([
+        expect.objectContaining({ sessionId: SESSION_ID, cwd }),
+      ]);
+    });
+
     it("applies the cwd filter against the decoded cwd", async () => {
       writeSession({
         sessionCwd: "/Users/dev/project-a",

package/src/__tests__/providers/grok/GrokSessionLocator.test.ts

@@ -0,0 +1,106 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import type { ProcessInfo } from "../../../adapters/AgentAdapter.js";
+import { GrokSessionLocator } from "../../../providers/grok/GrokSessionLocator.js";
+
+describe("GrokSessionLocator", () => {
+  let baseDir: string;
+  let locator: GrokSessionLocator;
+
+  beforeEach(() => {
+    baseDir = fs.mkdtempSync(path.join(os.tmpdir(), "grok-locator-test-"));
+    locator = new GrokSessionLocator({ baseDir });
+  });
+
+  afterEach(() => {
+    fs.rmSync(baseDir, { recursive: true, force: true });
+  });
+
+  function writeSession(cwd: string, id: string, mtime?: Date): string {
+    const sessionDir = path.join(baseDir, "sessions", encodeURIComponent(cwd), id);
+    fs.mkdirSync(sessionDir, { recursive: true });
+    const chatPath = path.join(sessionDir, "chat_history.jsonl");
+    fs.writeFileSync(chatPath, "");
+    if (mtime) fs.utimesSync(chatPath, mtime, mtime);
+    return sessionDir;
+  }
+
+  function proc(overrides: Partial<ProcessInfo> = {}): ProcessInfo {
+    return { pid: 4242, command: "grok", cwd: "/repo/app", tty: "ttys001", ...overrides };
+  }
+
+  describe("matchRunningProcesses", () => {
+    it("prefers the active_sessions.json cwd over the process cwd", () => {
+      const sessionDir = writeSession("/repo/real", "s1");
+      fs.writeFileSync(
+        path.join(baseDir, "active_sessions.json"),
+        JSON.stringify([{ pid: 4242, cwd: "/repo/real" }]),
+      );
+
+      expect(locator.matchRunningProcesses([proc({ cwd: "/wrong" })])).toEqual([
+        { process: expect.objectContaining({ pid: 4242 }), cwd: "/repo/real", sessionDir },
+      ]);
+    });
+
+    it("ignores a malformed active_sessions.json and falls back to the process cwd", () => {
+      const sessionDir = writeSession("/repo/app", "s1");
+      fs.writeFileSync(path.join(baseDir, "active_sessions.json"), "{not json");
+
+      expect(locator.matchRunningProcesses([proc()])[0]).toMatchObject({
+        cwd: "/repo/app",
+        sessionDir,
+      });
+    });
+
+    it("picks the session with the newest chat_history.jsonl", () => {
+      writeSession("/repo/app", "old", new Date(Date.now() - 60_000));
+      const newest = writeSession("/repo/app", "new");
+
+      expect(locator.matchRunningProcesses([proc()])[0].sessionDir).toBe(newest);
+    });
+
+    it("returns a null sessionDir when no cwd is known", () => {
+      expect(locator.matchRunningProcesses([proc({ cwd: "" })])[0]).toMatchObject({
+        cwd: "",
+        sessionDir: null,
+      });
+    });
+  });
+
+  describe("historical sessions", () => {
+    it("discovers session dirs with the decoded group cwd", () => {
+      const a = writeSession("/repo/a", "s1");
+      const b = writeSession("/repo/b", "s2");
+
+      expect(locator.discoverHistoricalSessionDirs()).toEqual(
+        expect.arrayContaining([
+          { sessionDir: a, defaultCwd: "/repo/a" },
+          { sessionDir: b, defaultCwd: "/repo/b" },
+        ]),
+      );
+    });
+
+    it("prefers the .cwd file over the encoded group name", () => {
+      const groupDir = path.join(baseDir, "sessions", "slug-abc123");
+      fs.mkdirSync(path.join(groupDir, "s1"), { recursive: true });
+      fs.writeFileSync(path.join(groupDir, ".cwd"), "/very/long/path\n");
+
+      expect(locator.discoverHistoricalSessionDirs()).toEqual([
+        { sessionDir: path.join(groupDir, "s1"), defaultCwd: "/very/long/path" },
+      ]);
+    });
+
+    it("finds session dirs by id and rejects unsafe ids", () => {
+      const dir = writeSession("/repo/a", "s1");
+      writeSession("/repo/b", "s2");
+
+      expect(locator.findHistoricalSessionDirsById("s1")).toEqual([
+        { sessionDir: dir, defaultCwd: "/repo/a" },
+      ]);
+      expect(locator.findHistoricalSessionDirsById("../s1")).toEqual([]);
+    });
+  });
+});

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

@@ -121,6 +121,24 @@ describe("OpenCodeAdapter", () => {
     ]);
     expect(adapter.getConversation("/not-an-opencode-ref")).toEqual([]);
   });
+
+  it("finds an exact session ID with a targeted database query", async () => {
+    const now = Date.now();
+    writeDatabase(dbPath, {
+      sessions: [
+        { id: "wanted", directory: "/repo", timeCreated: now },
+        { id: "other", directory: "/other", timeCreated: now - 1_000 },
+      ],
+    });
+
+    await expect(adapter.findSessionsById("wanted")).resolves.toEqual([
+      expect.objectContaining({
+        type: "opencode",
+        sessionId: "wanted",
+        sessionFilePath: `${dbPath}::wanted`,
+      }),
+    ]);
+  });
 });
 
 function writeDatabase(

package/src/__tests__/providers/pi/PiAdapter.test.ts

@@ -260,6 +260,21 @@ describe("PiAdapter", () => {
     ]);
   });
 
+  it("finds an exact session ID from the filename suffix", async () => {
+    const wanted = writePiSession("/repo/wanted", [
+      { timestamp: "2026-06-10T08:58:20.754Z", sessionId: "sess-wanted", cwd: "/repo/wanted" },
+      { role: "user", content: "wanted" },
+    ]);
+    writePiSession("/repo/other", [
+      { timestamp: "2026-06-10T08:58:20.754Z", sessionId: "sess-other", cwd: "/repo/other" },
+      { role: "user", content: "other" },
+    ]);
+
+    await expect(adapter.findSessionsById("sess-wanted")).resolves.toEqual([
+      expect.objectContaining({ sessionId: "sess-wanted", sessionFilePath: wanted }),
+    ]);
+  });
+
   function makeProcess(overrides: Partial<ProcessInfo>): ProcessInfo {
     return {
       pid: 1,

package/src/__tests__/utils/agents.test.ts

@@ -21,4 +21,11 @@ describe("AGENTS", () => {
     expect(AGENTS.grok_cli.matches("/Users/dev/.grok/bin/grok --always-approve")).toBe(true);
     expect(AGENTS.grok_cli.matches("node /repo/feature-grok-cli/script.js")).toBe(false);
   });
+
+  it("includes Kiro as a startable agent", () => {
+    expect(AGENTS.kiro.command).toBe("kiro-cli");
+    expect(AGENTS.kiro.matches("kiro-cli")).toBe(true);
+    expect(AGENTS.kiro.matches("/usr/local/bin/kiro --model x")).toBe(true);
+    expect(AGENTS.kiro.matches("node /repo/feature-kiro-adapter/script.js")).toBe(false);
+  });
 });

package/src/__tests__/utils/session.test.ts

@@ -5,7 +5,7 @@
 import type { MockedFunction } from "vitest";
 
 import * as fs from "fs";
-import { batchGetSessionFileBirthtimes } from "../../utils/session.js";
+import { batchGetSessionFileBirthtimes, isSafePathSegment } from "../../utils/session.js";
 
 vi.mock("fs", () => ({
   readdirSync: vi.fn(),
@@ -15,6 +15,16 @@ vi.mock("fs", () => ({
 const mockedReaddirSync = fs.readdirSync as MockedFunction<typeof fs.readdirSync>;
 const mockedStatSync = fs.statSync as MockedFunction<typeof fs.statSync>;
 
+describe("isSafePathSegment", () => {
+  it.each(["", ".", "..", "nested/session", "bad\0id"])("rejects unsafe segment %j", (value) => {
+    expect(isSafePathSegment(value)).toBe(false);
+  });
+
+  it.each(["session-id", ".hidden-session"])("accepts safe segment %j", (value) => {
+    expect(isSafePathSegment(value)).toBe(true);
+  });
+});
+
 describe("batchGetSessionFileBirthtimes", () => {
   beforeEach(() => {
     mockedReaddirSync.mockReset();

package/src/adapters/AgentAdapter.ts

@@ -12,6 +12,8 @@ export type AgentType =
   | "claude"
   | "gemini_cli"
   | "grok_cli"
+  | "kiro"
+  | "antigravity_cli"
   | "codex"
   | "opencode"
   | "copilot"
@@ -208,4 +210,13 @@ export interface AgentAdapter {
    * @returns Array of sessions discovered on disk
    */
   listSessions(opts?: ListSessionsOptions): Promise<SessionSummary[]>;
+
+  /**
+   * Resolve exact historical session matches without enumerating every summary.
+   *
+   * Built-in adapters implement this using their provider-native storage shape.
+   * The method remains optional so external adapters can fall back to
+   * {@link listSessions} until they adopt direct lookup.
+   */
+  findSessionsById?(sessionId: string): Promise<SessionSummary[]>;
 }