@ai-devkit/agent-manager 0.35.0 → 0.37.0

package/src/__tests__/harnesses/gemini/GeminiSessionLocator.test.ts

@@ -0,0 +1,396 @@
+/**
+ * I/O-bounded discovery tests for GeminiSessionLocator (issue #263).
+ *
+ * `fs` is wrapped so every open/read is recorded, which lets the tests
+ * assert exactly which chat files discovery touches and how many bytes
+ * of chat content it reads per refresh.
+ */
+
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+import { GeminiCliAdapter } from "../../../harnesses/gemini/GeminiCliAdapter.js";
+import { GeminiSessionLocator } from "../../../harnesses/gemini/GeminiSessionLocator.js";
+import type { ProcessInfo } from "../../../adapters/AgentAdapter.js";
+import { AgentRegistry } from "../../../utils/AgentRegistry.js";
+
+vi.mock("fs", async (importOriginal) => {
+  const actual = (await importOriginal()) as typeof import("fs");
+  const wrapped = {
+    ...actual,
+    openSync: vi.fn(actual.openSync),
+    readSync: vi.fn(actual.readSync),
+    readFileSync: vi.fn(actual.readFileSync),
+  };
+  return { ...wrapped, default: wrapped };
+});
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+interface IoLog {
+  /** Paths passed to openSync/readFileSync, in call order. */
+  opened: string[];
+  /** Bytes returned by readSync/readFileSync, keyed by path. */
+  bytesByPath: Map<string, number>;
+}
+
+function startIoLog(): IoLog {
+  const log: IoLog = { opened: [], bytesByPath: new Map() };
+  const fdPaths = new Map<number, string>();
+  const openSync = vi.mocked(fs.openSync);
+  const readSync = vi.mocked(fs.readSync);
+  const readFileSync = vi.mocked(fs.readFileSync);
+
+  const addBytes = (p: string, n: number) =>
+    log.bytesByPath.set(p, (log.bytesByPath.get(p) ?? 0) + n);
+
+  openSync.mockImplementation(((p: fs.PathLike, ...rest: unknown[]) => {
+    const fd = (fsActual.openSync as (...args: unknown[]) => number)(p, ...rest);
+    log.opened.push(String(p));
+    fdPaths.set(fd, String(p));
+    return fd;
+  }) as typeof fs.openSync);
+  readSync.mockImplementation(((fd: number, ...rest: unknown[]) => {
+    const n = (fsActual.readSync as (...args: unknown[]) => number)(fd, ...rest);
+    addBytes(fdPaths.get(fd) ?? `fd:${fd}`, n);
+    return n;
+  }) as typeof fs.readSync);
+  readFileSync.mockImplementation(((p: fs.PathOrFileDescriptor, ...rest: unknown[]) => {
+    const result = (fsActual.readFileSync as (...args: unknown[]) => string | Buffer)(p, ...rest);
+    log.opened.push(String(p));
+    addBytes(String(p), Buffer.byteLength(result));
+    return result;
+  }) as typeof fs.readFileSync);
+  return log;
+}
+
+let fsActual: typeof import("fs");
+
+function chatBytes(log: IoLog): number {
+  let total = 0;
+  for (const [p, n] of log.bytesByPath) {
+    if (isChatFile(p)) total += n;
+  }
+  return total;
+}
+
+function openedChatFiles(log: IoLog): string[] {
+  return [...new Set(log.opened.filter(isChatFile))].sort();
+}
+
+function isChatFile(p: string): boolean {
+  return path.basename(path.dirname(p)) === "chats";
+}
+
+function sha256(value: string): string {
+  return crypto.createHash("sha256").update(value).digest("hex");
+}
+
+function writeChat(
+  tmpDir: string,
+  dirName: string,
+  fileName: string,
+  body: Record<string, unknown>,
+  mtime?: Date,
+): string {
+  const chatsDir = path.join(tmpDir, dirName, "chats");
+  fsActual.mkdirSync(chatsDir, { recursive: true });
+  const filePath = path.join(chatsDir, fileName);
+  // Gemini CLI writes the legacy .json format with 2-space indentation.
+  fsActual.writeFileSync(filePath, JSON.stringify(body, null, 2));
+  if (mtime) fsActual.utimesSync(filePath, mtime, mtime);
+  return filePath;
+}
+
+function writeProjectMarker(tmpDir: string, dirName: string, projectRoot: string): void {
+  fsActual.mkdirSync(path.join(tmpDir, dirName), { recursive: true });
+  fsActual.writeFileSync(path.join(tmpDir, dirName, ".project_root"), projectRoot);
+}
+
+function sessionBody(projectRoot: string, sessionId: string, extraMessages = 1) {
+  const now = new Date().toISOString();
+  return {
+    sessionId,
+    projectHash: sha256(projectRoot),
+    startTime: now,
+    lastUpdated: now,
+    kind: "main",
+    directories: [projectRoot],
+    messages: Array.from({ length: extraMessages }, (_, i) => ({
+      id: `m${i}`,
+      timestamp: now,
+      type: "user",
+      content: [{ text: `message ${i} for ${sessionId}` }],
+    })),
+  };
+}
+
+function geminiProcess(pid: number, cwd: string, startTime = new Date()): ProcessInfo {
+  return { pid, command: "node /usr/local/bin/gemini", cwd, tty: "ttys001", startTime };
+}
+
+describe("GeminiSessionLocator — bounded discovery (#263)", () => {
+  let tmpHome: string;
+  let tmpDir: string;
+  let locator: GeminiSessionLocator;
+
+  beforeAll(async () => {
+    fsActual = await vi.importActual<typeof import("fs")>("fs");
+  });
+
+  beforeEach(() => {
+    tmpHome = fsActual.mkdtempSync(path.join(os.tmpdir(), "gemini-locator-test-"));
+    tmpDir = path.join(tmpHome, ".gemini", "tmp");
+    fsActual.mkdirSync(tmpDir, { recursive: true });
+    locator = new GeminiSessionLocator({ geminiTmpDir: tmpDir });
+  });
+
+  afterEach(() => {
+    fsActual.rmSync(tmpHome, { recursive: true, force: true });
+  });
+
+  /**
+   * 20 projects x 25 chats = 500 historical fixtures. Half the projects use
+   * Gemini's current slug + `.project_root` layout, half the legacy
+   * sha256(projectRoot) directory name. Every project has fresh files so
+   * only directory pruning (not the mtime window) can exclude them.
+   */
+  function seedHistory(): { liveRoot: string; liveRecent: string } {
+    const old = new Date(Date.now() - 3 * DAY_MS);
+    let liveRecent = "";
+    const liveRoot = "/work/project-07";
+
+    for (let p = 0; p < 20; p++) {
+      const root = `/work/project-${String(p).padStart(2, "0")}`;
+      const dirName = p % 2 === 1 ? `project-${String(p).padStart(2, "0")}` : sha256(root);
+      if (p % 2 === 1) writeProjectMarker(tmpDir, dirName, root);
+
+      for (let f = 0; f < 25; f++) {
+        const isRecent = f === 24;
+        const filePath = writeChat(
+          tmpDir,
+          dirName,
+          `session-2026-09-${String(f + 1).padStart(2, "0")}T00-00-${p}-${f}.json`,
+          sessionBody(root, `s-${p}-${f}`),
+          isRecent ? undefined : old,
+        );
+        if (root === liveRoot && isRecent) liveRecent = filePath;
+      }
+    }
+    return { liveRoot, liveRecent };
+  }
+
+  it("opens only the live process's project chat files inside the mtime window", () => {
+    const { liveRoot, liveRecent } = seedHistory();
+    const log = startIoLog();
+
+    const result = locator.discoverSessions([geminiProcess(1, liveRoot)]);
+
+    expect(result.sessions.map((s) => s.filePath)).toEqual([liveRecent]);
+    expect(result.sessions[0]).toMatchObject({ sessionId: "s-7-24", resolvedCwd: liveRoot });
+    expect(openedChatFiles(log)).toEqual([liveRecent]);
+  });
+
+  it("prunes legacy hash-named project dirs without opening their chats", () => {
+    const { liveRecent } = seedHistory();
+    const legacyRoot = "/work/project-04"; // even index => sha256-named dir
+    const log = startIoLog();
+
+    const result = locator.discoverSessions([geminiProcess(1, legacyRoot)]);
+
+    expect(result.sessions.map((s) => s.sessionId)).toEqual(["s-4-24"]);
+    const opened = openedChatFiles(log);
+    expect(opened).toHaveLength(1);
+    expect(opened[0]).toContain(sha256(legacyRoot));
+    expect(opened).not.toContain(liveRecent);
+  });
+
+  it("does not expose a content cache and reads only a bounded head of large chats", () => {
+    const root = "/work/big";
+    const bigPath = writeChat(tmpDir, "big", "session-big.json", sessionBody(root, "s-big", 4000));
+    const size = fsActual.statSync(bigPath).size;
+    expect(size).toBeGreaterThan(256 * 1024);
+    const log = startIoLog();
+
+    const result = locator.discoverSessions([geminiProcess(1, root)]);
+
+    expect(result.sessions.map((s) => s.sessionId)).toEqual(["s-big"]);
+    expect(result).not.toHaveProperty("contentCache");
+    expect(chatBytes(log)).toBeLessThanOrEqual(16 * 1024);
+  });
+
+  it("reads 0 bytes of chat content on a refresh when files are unchanged", () => {
+    seedHistory();
+    const proc = geminiProcess(1, "/work/project-07");
+    const first = locator.discoverSessions([proc]);
+    const log = startIoLog();
+
+    const second = locator.discoverSessions([proc]);
+
+    expect(second.sessions).toEqual(first.sessions);
+    expect(chatBytes(log)).toBe(0);
+    expect(log.opened).toEqual([]);
+  });
+
+  it("re-reads metadata once a cached chat file changes", () => {
+    const root = "/work/changing";
+    const filePath = writeChat(tmpDir, "changing", "session-c.json", sessionBody(root, "s-1"));
+    const proc = geminiProcess(1, root);
+    expect(locator.discoverSessions([proc]).sessions[0].sessionId).toBe("s-1");
+
+    fsActual.writeFileSync(filePath, JSON.stringify(sessionBody(root, "s-2", 3), null, 2));
+    const log = startIoLog();
+
+    expect(locator.discoverSessions([proc]).sessions[0].sessionId).toBe("s-2");
+    expect(chatBytes(log)).toBeGreaterThan(0);
+  });
+
+  it("falls back to scanning dirs without a recognisable layout", () => {
+    const root = "/work/unknown-layout";
+    writeChat(tmpDir, "opaque", "session-u.json", sessionBody(root, "s-u"));
+
+    const result = locator.discoverSessions([geminiProcess(1, root)]);
+
+    expect(result.sessions.map((s) => s.sessionId)).toEqual(["s-u"]);
+  });
+
+  it("skips slug dirs whose .project_root names a different project", () => {
+    writeProjectMarker(tmpDir, "other", "/work/other");
+    writeChat(tmpDir, "other", "session-o.json", sessionBody("/work/mine", "s-o"));
+    const log = startIoLog();
+
+    const result = locator.discoverSessions([geminiProcess(1, "/work/mine")]);
+
+    expect(result.sessions).toEqual([]);
+    expect(openedChatFiles(log)).toEqual([]);
+  });
+
+  it("matches a subdirectory process against the project-root marker", () => {
+    writeProjectMarker(tmpDir, "mono", "/work/mono");
+    writeChat(tmpDir, "mono", "session-m.json", sessionBody("/work/mono", "s-m"));
+
+    const result = locator.discoverSessions([geminiProcess(1, "/work/mono/packages/a")]);
+
+    expect(result.sessions).toHaveLength(1);
+    expect(result.sessions[0].resolvedCwd).toBe("/work/mono/packages/a");
+  });
+
+  it("does not apply an mtime window when no process has a start time", () => {
+    const root = "/work/nostart";
+    writeChat(
+      tmpDir,
+      "nostart",
+      "session-n.json",
+      sessionBody(root, "s-n"),
+      new Date(Date.now() - 30 * DAY_MS),
+    );
+    const proc: ProcessInfo = { pid: 1, command: "gemini", cwd: root, tty: "ttys001" };
+
+    expect(locator.discoverSessions([proc]).sessions.map((s) => s.sessionId)).toEqual(["s-n"]);
+  });
+
+  it("keeps sessions modified within the matching tolerance before process start", () => {
+    const root = "/work/tolerance";
+    const start = new Date();
+    writeChat(
+      tmpDir,
+      "tolerance",
+      "session-t.json",
+      sessionBody(root, "s-t"),
+      new Date(start.getTime() - 60 * 1000),
+    );
+
+    const result = locator.discoverSessions([geminiProcess(1, root, start)]);
+
+    expect(result.sessions.map((s) => s.sessionId)).toEqual(["s-t"]);
+  });
+
+  it("falls back to a full parse when the head lacks the metadata keys", () => {
+    const root = "/work/late-keys";
+    const chatsDir = path.join(tmpDir, "late", "chats");
+    fsActual.mkdirSync(chatsDir, { recursive: true });
+    const body = {
+      messages: Array.from({ length: 2000 }, (_, i) => ({ id: `m${i}`, type: "user" })),
+      sessionId: "s-late",
+      projectHash: sha256(root),
+    };
+    fsActual.writeFileSync(path.join(chatsDir, "session-late.json"), JSON.stringify(body));
+
+    const result = locator.discoverSessions([geminiProcess(1, root)]);
+
+    expect(result.sessions.map((s) => s.sessionId)).toEqual(["s-late"]);
+  });
+});
+
+describe("GeminiCliAdapter — refresh I/O (#263)", () => {
+  let tmpHome: string;
+
+  beforeAll(async () => {
+    fsActual = await vi.importActual<typeof import("fs")>("fs");
+  });
+
+  beforeEach(() => {
+    tmpHome = fsActual.mkdtempSync(path.join(os.tmpdir(), "gemini-adapter-io-test-"));
+  });
+
+  afterEach(() => {
+    fsActual.rmSync(tmpHome, { recursive: true, force: true });
+  });
+
+  it("reads 0 bytes of chat content on the second detectAgents with unchanged files", async () => {
+    const tmpDir = path.join(tmpHome, ".gemini", "tmp");
+    const root = "/work/live";
+    writeProjectMarker(tmpDir, "live", root);
+    const sessionPath = writeChat(tmpDir, "live", "session-live.json", sessionBody(root, "s-live"));
+    for (let i = 0; i < 10; i++) {
+      writeChat(
+        tmpDir,
+        "live",
+        `session-old-${i}.json`,
+        sessionBody(root, `s-old-${i}`),
+        new Date(Date.now() - 2 * DAY_MS),
+      );
+    }
+
+    const adapter = new GeminiCliAdapter(new AgentRegistry(path.join(tmpHome, "agents.json")), {
+      geminiTmpDir: tmpDir,
+    });
+    const context = { processes: [geminiProcess(4242, root)] };
+
+    const first = await adapter.detectAgents(context);
+    expect(first).toHaveLength(1);
+    expect(first[0]).toMatchObject({ sessionId: "s-live", sessionFilePath: sessionPath });
+
+    const log = startIoLog();
+    const second = await adapter.detectAgents(context);
+
+    expect(second).toHaveLength(1);
+    expect(second[0]).toMatchObject({
+      sessionId: first[0].sessionId,
+      sessionFilePath: first[0].sessionFilePath,
+      summary: first[0].summary,
+    });
+    expect(chatBytes(log)).toBe(0);
+  });
+
+  it("re-parses the matched session after it is appended to", async () => {
+    const tmpDir = path.join(tmpHome, ".gemini", "tmp");
+    const root = "/work/appending";
+    writeProjectMarker(tmpDir, "appending", root);
+    const sessionPath = writeChat(tmpDir, "appending", "session-a.json", sessionBody(root, "s-a"));
+    const adapter = new GeminiCliAdapter(new AgentRegistry(path.join(tmpHome, "agents.json")), {
+      geminiTmpDir: tmpDir,
+    });
+    const context = { processes: [geminiProcess(4343, root)] };
+
+    const first = await adapter.detectAgents(context);
+    expect(first[0].summary).toBe("message 0 for s-a");
+
+    fsActual.writeFileSync(sessionPath, JSON.stringify(sessionBody(root, "s-a", 3), null, 2));
+    const second = await adapter.detectAgents(context);
+
+    expect(second[0]).toMatchObject({ sessionId: "s-a", summary: "message 2 for s-a" });
+  });
+});

package/src/__tests__/{providers → harnesses}/grok/GrokAgentMapper.test.ts

@@ -1,8 +1,8 @@
 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";
+import { GrokAgentMapper } from "../../../harnesses/grok/GrokAgentMapper.js";
+import type { GrokSession } from "../../../harnesses/grok/GrokSessionParser.js";
 
 function makeProcess(overrides: Partial<ProcessInfo> = {}): ProcessInfo {
   return { pid: 123, command: "grok", cwd: "/repo/my-app", tty: "ttys001", ...overrides };

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

@@ -10,7 +10,7 @@ import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
 
-import { GrokCliAdapter } from "../../../providers/grok/GrokCliAdapter.js";
+import { GrokCliAdapter } from "../../../harnesses/grok/GrokCliAdapter.js";
 import type { ProcessInfo } from "../../../adapters/AgentAdapter.js";
 import { AgentStatus } from "../../../adapters/AgentAdapter.js";
 import {

package/src/__tests__/harnesses/grok/GrokIncrementalRefresh.test.ts

@@ -0,0 +1,170 @@
+/**
+ * Refresh-path I/O tests for the Grok adapter: repeated `detectAgents()` calls
+ * must only read chat_history.jsonl bytes that changed since the last refresh.
+ */
+
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+import type { ProcessInfo } from "../../../adapters/AgentAdapter.js";
+import { GrokCliAdapter } from "../../../harnesses/grok/GrokCliAdapter.js";
+
+vi.mock("fs", async (importOriginal) => {
+  const actual = (await importOriginal()) as typeof import("fs");
+  return {
+    ...actual,
+    openSync: vi.fn(actual.openSync),
+    readSync: vi.fn(actual.readSync),
+    readFileSync: vi.fn(actual.readFileSync),
+  };
+});
+
+const mockedOpenSync = vi.mocked(fs.openSync);
+const mockedReadSync = vi.mocked(fs.readSync);
+const mockedReadFileSync = vi.mocked(fs.readFileSync);
+
+/** Bytes read from `filePath` via readFileSync or fd reads since the last `resetReads()`. */
+function bytesReadFrom(filePath: string): number {
+  // fds are reused after close, so attribute each read to the latest open of that fd
+  const opens = mockedOpenSync.mock.calls.map((call, index) => ({
+    path: String(call[0]),
+    fd: mockedOpenSync.mock.results[index]?.value as number,
+    order: mockedOpenSync.mock.invocationCallOrder[index],
+  }));
+
+  let total = 0;
+  mockedReadSync.mock.calls.forEach((call, index) => {
+    const result = mockedReadSync.mock.results[index];
+    const order = mockedReadSync.mock.invocationCallOrder[index];
+    const open = opens.filter((o) => o.fd === call[0] && o.order < order).at(-1);
+    if (result?.type === "return" && open?.path === filePath) {
+      total += result.value as number;
+    }
+  });
+  mockedReadFileSync.mock.calls.forEach((call, index) => {
+    const result = mockedReadFileSync.mock.results[index];
+    if (result?.type === "return" && String(call[0]) === filePath) {
+      total += Buffer.byteLength(result.value as string | Buffer);
+    }
+  });
+  return total;
+}
+
+function resetReads(): void {
+  mockedOpenSync.mockClear();
+  mockedReadSync.mockClear();
+  mockedReadFileSync.mockClear();
+}
+
+const userRecord = (text: string) => ({
+  type: "user",
+  content: [{ type: "text", text: `<user_query>\n${text}\n</user_query>` }],
+});
+const assistantRecord = (text: string) => ({
+  type: "assistant",
+  content: [{ type: "text", text }],
+});
+
+describe("Grok incremental transcript reads across detectAgents() refreshes", () => {
+  let originalHome: string | undefined;
+  let originalGrokHome: string | undefined;
+  let tmpHome: string;
+  let chatFile: string;
+  let adapter: GrokCliAdapter;
+  let processes: ProcessInfo[];
+
+  const pid = 73001;
+  const cwd = "/repo/grok";
+
+  beforeEach(() => {
+    originalHome = process.env.HOME;
+    originalGrokHome = process.env.GROK_HOME;
+    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "grok-incremental-refresh-"));
+    process.env.HOME = tmpHome;
+    delete process.env.GROK_HOME;
+
+    const sessionDir = path.join(
+      tmpHome,
+      ".grok",
+      "sessions",
+      encodeURIComponent(cwd),
+      "019f16c3-0000-7000-8000-000000000001",
+    );
+    fs.mkdirSync(sessionDir, { recursive: true });
+    chatFile = path.join(sessionDir, "chat_history.jsonl");
+    // Large, newline-terminated transcript; the last record is left unterminated
+    // the way the existing Grok fixtures write it.
+    fs.writeFileSync(
+      chatFile,
+      [
+        userRecord("first task"),
+        assistantRecord("x".repeat(300_000)),
+        { type: "user", content: [{ type: "text", text: "<user_info>OS</user_info>" }] },
+        userRecord("second task"),
+      ]
+        .map((record) => JSON.stringify(record))
+        .join("\n"),
+    );
+    fs.writeFileSync(
+      path.join(tmpHome, ".grok", "active_sessions.json"),
+      JSON.stringify([{ pid, cwd, opened_at: 1 }]),
+    );
+
+    processes = [{ pid, command: "grok", cwd, tty: "ttys003", startTime: new Date() }];
+    adapter = new GrokCliAdapter();
+    resetReads();
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    if (originalGrokHome === undefined) delete process.env.GROK_HOME;
+    else process.env.GROK_HOME = originalGrokHome;
+    fs.rmSync(tmpHome, { recursive: true, force: true });
+  });
+
+  const detect = () => adapter.detectAgents({ processes });
+  const summaryOf = (agents: Awaited<ReturnType<typeof detect>>) => ({
+    sessionId: agents[0]?.sessionId,
+    status: agents[0]?.status,
+    summary: agents[0]?.summary,
+  });
+
+  it("reads 0 transcript bytes on a second refresh when nothing changed", async () => {
+    const first = await detect();
+    expect(bytesReadFrom(chatFile)).toBe(fs.statSync(chatFile).size);
+    expect(first[0].summary).toBe("second task");
+
+    resetReads();
+    const second = await detect();
+
+    expect(bytesReadFrom(chatFile)).toBe(0);
+    expect(summaryOf(second)).toEqual(summaryOf(first));
+  });
+
+  it("reads at most the appended bytes plus 64 KiB after an append", async () => {
+    await detect();
+
+    const append = `\n${JSON.stringify(assistantRecord("done"))}\n${JSON.stringify(
+      userRecord("follow-up task"),
+    )}\n`;
+    fs.appendFileSync(chatFile, append);
+
+    resetReads();
+    const agents = await detect();
+
+    expect(bytesReadFrom(chatFile)).toBeGreaterThan(0);
+    expect(bytesReadFrom(chatFile)).toBeLessThanOrEqual(Buffer.byteLength(append) + 64 * 1024);
+    expect(agents[0].summary).toBe("follow-up task");
+  });
+
+  it("evicts cache entries for transcripts absent from the latest refresh", async () => {
+    await detect();
+    expect((adapter as any).parser.sessionCache.size).toBe(1);
+
+    processes = [];
+    await detect();
+
+    expect((adapter as any).parser.sessionCache.size).toBe(0);
+  });
+});

package/src/__tests__/{providers → harnesses}/grok/GrokSessionLocator.test.ts

@@ -4,7 +4,7 @@ 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";
+import { GrokSessionLocator } from "../../../harnesses/grok/GrokSessionLocator.js";
 
 describe("GrokSessionLocator", () => {
   let baseDir: string;