@ai-devkit/agent-manager 0.36.0 → 0.38.0

package/src/__tests__/providers/claude/ClaudeSessionLocator.test.ts

@@ -1,434 +0,0 @@
-import type { MockedFunction } from "vitest";
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import { AgentStatus, type ProcessInfo } from "../../../adapters/AgentAdapter.js";
-import { ClaudeSessionLocator } from "../../../providers/claude/ClaudeSessionLocator.js";
-import { batchGetSessionFileBirthtimes } from "../../../utils/session.js";
-import type { SessionFile } from "../../../utils/session.js";
-
-vi.mock("../../../utils/session.js", async (importOriginal) => {
-  const actual = (await importOriginal()) as typeof import("../../../utils/session.js");
-  return {
-    ...actual,
-    batchGetSessionFileBirthtimes: vi.fn(),
-  };
-});
-
-const mockedBatchGetSessionFileBirthtimes = batchGetSessionFileBirthtimes as MockedFunction<
-  typeof batchGetSessionFileBirthtimes
->;
-
-const tmpDirs: string[] = [];
-
-function makeTmpDir(): string {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "claude-locator-test-"));
-  tmpDirs.push(dir);
-  return dir;
-}
-
-function makeProcess(overrides: Partial<ProcessInfo> = {}): ProcessInfo {
-  return {
-    pid: 123,
-    command: "claude",
-    cwd: "/repo/my-app",
-    tty: "ttys001",
-    startTime: new Date("2026-08-23T10:00:00.000Z"),
-    ...overrides,
-  };
-}
-
-type PidFileMatching = (processes: ProcessInfo[]) => {
-  direct: Array<{ process: ProcessInfo; sessionFile: SessionFile }>;
-  fallback: ProcessInfo[];
-};
-
-/** `tryPidFileMatching` is private; tests drive it directly like the sibling adapter suites do. */
-function bindPidFileMatching(locator: ClaudeSessionLocator): PidFileMatching {
-  return (locator as unknown as { tryPidFileMatching: PidFileMatching }).tryPidFileMatching.bind(
-    locator,
-  ) as PidFileMatching;
-}
-
-/** `getProjectDir` is private; bound here so the encoding tests read cleanly. */
-function bindProjectDir(locator: ClaudeSessionLocator): (cwd: string) => string {
-  return (locator as unknown as { getProjectDir: (cwd: string) => string }).getProjectDir.bind(
-    locator,
-  );
-}
-
-describe("ClaudeSessionLocator", () => {
-  beforeEach(() => {
-    mockedBatchGetSessionFileBirthtimes.mockReset();
-  });
-
-  afterEach(() => {
-    for (const dir of tmpDirs.splice(0)) {
-      fs.rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("matches resumed sessions directly and carries live PID status metadata", () => {
-    const root = makeTmpDir();
-    const projectsDir = path.join(root, "projects");
-    const sessionsDir = path.join(root, "sessions");
-    const cwd = "/repo/my-app";
-    const sessionId = "12345678-1234-1234-1234-123456789abc";
-    const projectDir = path.join(projectsDir, "-repo-my-app");
-    const sessionFile = path.join(projectDir, `${sessionId}.jsonl`);
-    fs.mkdirSync(projectDir, { recursive: true });
-    fs.mkdirSync(sessionsDir, { recursive: true });
-    fs.writeFileSync(sessionFile, "{}\n");
-    fs.writeFileSync(
-      path.join(sessionsDir, "123.json"),
-      JSON.stringify({
-        pid: 123,
-        sessionId,
-        cwd,
-        startedAt: new Date("2026-08-23T10:00:00.000Z").getTime(),
-        kind: "interactive",
-        entrypoint: "cli",
-        status: "waiting",
-        waitingFor: "approve Read",
-      }),
-    );
-
-    const locator = new ClaudeSessionLocator({ projectsDir, sessionsDir });
-    const matches = locator.matchRunningProcesses([
-      makeProcess({ command: `claude --resume ${sessionId}`, cwd }),
-    ]);
-
-    expect(matches.direct).toHaveLength(1);
-    expect(matches.legacyMatches).toEqual([]);
-    expect(matches.direct[0]).toMatchObject({
-      pidStatus: AgentStatus.WAITING,
-      waitingFor: "approve Read",
-      sessionFile: {
-        sessionId,
-        filePath: sessionFile,
-        projectDir,
-        resolvedCwd: cwd,
-      },
-    });
-  });
-  describe("discoverLiveSessions", () => {
-    let tmpDir: string;
-    let projectsDir: string;
-    let locator: ClaudeSessionLocator;
-
-    beforeEach(() => {
-      tmpDir = makeTmpDir();
-      projectsDir = path.join(tmpDir, "projects");
-      locator = new ClaudeSessionLocator({
-        projectsDir,
-        sessionsDir: path.join(tmpDir, "sessions"),
-      });
-    });
-
-    it("should return empty when projects dir does not exist", () => {
-      const missing = new ClaudeSessionLocator({
-        projectsDir: path.join(tmpDir, "nonexistent"),
-        sessionsDir: path.join(tmpDir, "sessions"),
-      });
-
-      const result = missing.discoverLiveSessions([
-        { pid: 1, command: "claude", cwd: "/test", tty: "" },
-      ]);
-      expect(result).toEqual([]);
-    });
-
-    it("should scan only directories matching process CWDs", () => {
-      // /my/project → -my-project (encoded dir)
-      const encodedDir = path.join(projectsDir, "-my-project");
-      fs.mkdirSync(encodedDir, { recursive: true });
-
-      // Also create another dir that should NOT be scanned
-      const otherDir = path.join(projectsDir, "-other-project");
-      fs.mkdirSync(otherDir, { recursive: true });
-
-      const mockFiles: SessionFile[] = [
-        {
-          sessionId: "s1",
-          filePath: path.join(encodedDir, "s1.jsonl"),
-          projectDir: encodedDir,
-          birthtimeMs: 1710800324000,
-          resolvedCwd: "",
-        },
-      ];
-      mockedBatchGetSessionFileBirthtimes.mockReturnValue(mockFiles);
-
-      const processes = [{ pid: 1, command: "claude", cwd: "/my/project", tty: "" }];
-
-      const result = locator.discoverLiveSessions(processes);
-      expect(result).toHaveLength(1);
-      expect(result[0].resolvedCwd).toBe("/my/project");
-      // batchGetSessionFileBirthtimes called once with all dirs
-      expect(mockedBatchGetSessionFileBirthtimes).toHaveBeenCalledTimes(1);
-      expect(mockedBatchGetSessionFileBirthtimes).toHaveBeenCalledWith([encodedDir]);
-    });
-
-    it("should return empty when encoded dir does not exist", () => {
-      fs.mkdirSync(projectsDir, { recursive: true });
-
-      // Process CWD /test encodes to -test, but that dir doesn't exist
-      const result = locator.discoverLiveSessions([
-        { pid: 1, command: "claude", cwd: "/test", tty: "" },
-      ]);
-      expect(result).toEqual([]);
-      expect(mockedBatchGetSessionFileBirthtimes).not.toHaveBeenCalled();
-    });
-
-    it("should deduplicate when multiple processes share same CWD", () => {
-      const encodedDir = path.join(projectsDir, "-my-project");
-      fs.mkdirSync(encodedDir, { recursive: true });
-
-      mockedBatchGetSessionFileBirthtimes.mockReturnValue([
-        {
-          sessionId: "s1",
-          filePath: path.join(encodedDir, "s1.jsonl"),
-          projectDir: encodedDir,
-          birthtimeMs: 1710800324000,
-          resolvedCwd: "",
-        },
-      ]);
-
-      const processes = [
-        { pid: 1, command: "claude", cwd: "/my/project", tty: "" },
-        { pid: 2, command: "claude", cwd: "/my/project", tty: "" },
-      ];
-
-      const result = locator.discoverLiveSessions(processes);
-      // Should only call batch once with deduplicated dir
-      expect(mockedBatchGetSessionFileBirthtimes).toHaveBeenCalledTimes(1);
-      expect(mockedBatchGetSessionFileBirthtimes).toHaveBeenCalledWith([encodedDir]);
-      expect(result).toHaveLength(1);
-    });
-
-    it("should skip processes with empty cwd", () => {
-      fs.mkdirSync(projectsDir, { recursive: true });
-
-      const result = locator.discoverLiveSessions([
-        { pid: 1, command: "claude", cwd: "", tty: "" },
-      ]);
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe("tryPidFileMatching", () => {
-    let tmpDir: string;
-    let sessionsDir: string;
-    let projectsDir: string;
-    let tryMatch: (processes: ProcessInfo[]) => {
-      direct: Array<{ process: ProcessInfo; sessionFile: SessionFile }>;
-      fallback: ProcessInfo[];
-    };
-
-    beforeEach(() => {
-      tmpDir = makeTmpDir();
-      sessionsDir = path.join(tmpDir, "sessions");
-      projectsDir = path.join(tmpDir, "projects");
-      fs.mkdirSync(sessionsDir, { recursive: true });
-      tryMatch = bindPidFileMatching(new ClaudeSessionLocator({ projectsDir, sessionsDir }));
-    });
-
-    const makeProc = (pid: number, cwd = "/project/test", startTime?: Date): ProcessInfo => ({
-      pid,
-      command: "claude",
-      cwd,
-      tty: "ttys001",
-      startTime,
-    });
-
-    const writePidFile = (pid: number, sessionId: string, cwd: string, startedAt: number) => {
-      fs.writeFileSync(
-        path.join(sessionsDir, `${pid}.json`),
-        JSON.stringify({ pid, sessionId, cwd, startedAt, kind: "interactive", entrypoint: "cli" }),
-      );
-    };
-
-    const writeJsonl = (cwd: string, sessionId: string) => {
-      const encoded = cwd.replace(/[^a-zA-Z0-9]/g, "-");
-      const projDir = path.join(projectsDir, encoded);
-      fs.mkdirSync(projDir, { recursive: true });
-      const filePath = path.join(projDir, `${sessionId}.jsonl`);
-      fs.writeFileSync(
-        filePath,
-        JSON.stringify({ type: "assistant", timestamp: new Date().toISOString() }),
-      );
-      return filePath;
-    };
-
-    it("should return direct match when PID file and JSONL both exist within time tolerance", () => {
-      const startTime = new Date();
-      const proc = makeProc(1001, "/project/test", startTime);
-      writePidFile(1001, "session-abc", "/project/test", startTime.getTime());
-      writeJsonl("/project/test", "session-abc");
-
-      const { direct, fallback } = tryMatch([proc]);
-
-      expect(direct).toHaveLength(1);
-      expect(fallback).toHaveLength(0);
-      expect(direct[0].sessionFile.sessionId).toBe("session-abc");
-      expect(direct[0].sessionFile.resolvedCwd).toBe("/project/test");
-      expect(direct[0].process.pid).toBe(1001);
-    });
-
-    it("should fall back when PID file exists but JSONL is missing", () => {
-      const startTime = new Date();
-      const proc = makeProc(1002, "/project/test", startTime);
-      writePidFile(1002, "nonexistent-session", "/project/test", startTime.getTime());
-      // No JSONL file written
-
-      const { direct, fallback } = tryMatch([proc]);
-
-      expect(direct).toHaveLength(0);
-      expect(fallback).toHaveLength(1);
-      expect(fallback[0].pid).toBe(1002);
-    });
-
-    it("should fall back when startedAt is stale (>60s from proc.startTime)", () => {
-      const startTime = new Date();
-      const staleTime = startTime.getTime() - 90_000; // 90 seconds earlier
-      const proc = makeProc(1003, "/project/test", startTime);
-      writePidFile(1003, "stale-session", "/project/test", staleTime);
-      writeJsonl("/project/test", "stale-session");
-
-      const { direct, fallback } = tryMatch([proc]);
-
-      expect(direct).toHaveLength(0);
-      expect(fallback).toHaveLength(1);
-    });
-
-    it("should accept PID file when startedAt is within 60s tolerance", () => {
-      const startTime = new Date();
-      const closeTime = startTime.getTime() - 30_000; // 30 seconds earlier — within tolerance
-      const proc = makeProc(1004, "/project/test", startTime);
-      writePidFile(1004, "close-session", "/project/test", closeTime);
-      writeJsonl("/project/test", "close-session");
-
-      const { direct, fallback } = tryMatch([proc]);
-
-      expect(direct).toHaveLength(1);
-      expect(fallback).toHaveLength(0);
-    });
-
-    it("should fall back when PID file is absent", () => {
-      const proc = makeProc(1005, "/project/test", new Date());
-      // No PID file written
-
-      const { direct, fallback } = tryMatch([proc]);
-
-      expect(direct).toHaveLength(0);
-      expect(fallback).toHaveLength(1);
-    });
-
-    it("should fall back when PID file contains malformed JSON", () => {
-      const proc = makeProc(1006, "/project/test", new Date());
-      fs.writeFileSync(path.join(sessionsDir, "1006.json"), "not valid json {{{");
-
-      expect(() => {
-        const { direct, fallback } = tryMatch([proc]);
-        expect(direct).toHaveLength(0);
-        expect(fallback).toHaveLength(1);
-      }).not.toThrow();
-    });
-
-    it("should fall back for all processes when sessions dir does not exist", () => {
-      const missingSessions = bindPidFileMatching(
-        new ClaudeSessionLocator({
-          projectsDir,
-          sessionsDir: path.join(tmpDir, "nonexistent-sessions"),
-        }),
-      );
-      const processes = [makeProc(2001, "/a", new Date()), makeProc(2002, "/b", new Date())];
-
-      const { direct, fallback } = missingSessions(processes);
-
-      expect(direct).toHaveLength(0);
-      expect(fallback).toHaveLength(2);
-    });
-
-    it("should correctly split mixed processes (some with PID files, some without)", () => {
-      const startTime = new Date();
-      const proc1 = makeProc(3001, "/project/one", startTime);
-      const proc2 = makeProc(3002, "/project/two", startTime);
-      const proc3 = makeProc(3003, "/project/three", startTime);
-
-      writePidFile(3001, "session-one", "/project/one", startTime.getTime());
-      writeJsonl("/project/one", "session-one");
-      writePidFile(3003, "session-three", "/project/three", startTime.getTime());
-      writeJsonl("/project/three", "session-three");
-      // proc2 has no PID file
-
-      const { direct, fallback } = tryMatch([proc1, proc2, proc3]);
-
-      expect(direct).toHaveLength(2);
-      expect(fallback).toHaveLength(1);
-      expect(direct.map((d) => d.process.pid).sort()).toEqual([3001, 3003]);
-      expect(fallback[0].pid).toBe(3002);
-    });
-
-    it("should skip stale-file check when proc.startTime is undefined", () => {
-      const proc = makeProc(4001, "/project/test", undefined); // no startTime
-      writePidFile(4001, "no-time-session", "/project/test", Date.now() - 999_999);
-      writeJsonl("/project/test", "no-time-session");
-
-      const { direct, fallback } = tryMatch([proc]);
-
-      // startTime undefined → stale check skipped → direct match
-      expect(direct).toHaveLength(1);
-      expect(fallback).toHaveLength(0);
-    });
-  });
-
-  describe("getProjectDir", () => {
-    let tmpDir: string;
-    let projectsDir: string;
-    let encode: (cwd: string) => string;
-
-    beforeEach(() => {
-      tmpDir = makeTmpDir();
-      projectsDir = path.join(tmpDir, "projects");
-      encode = bindProjectDir(
-        new ClaudeSessionLocator({
-          projectsDir,
-          sessionsDir: path.join(tmpDir, "sessions"),
-        }),
-      );
-    });
-
-    it("should replace path separators with hyphens", () => {
-      expect(encode("/Users/foo/bar")).toBe(path.join(projectsDir, "-Users-foo-bar"));
-    });
-
-    it("should encode underscores as hyphens (matches Claude Code CLI)", () => {
-      expect(encode("/Users/foo/my_project")).toBe(path.join(projectsDir, "-Users-foo-my-project"));
-    });
-
-    it("should encode dots as hyphens", () => {
-      expect(encode("/Users/foo/.worktrees/x")).toBe(
-        path.join(projectsDir, "-Users-foo--worktrees-x"),
-      );
-    });
-
-    it("should collide paths that differ only in non-alphanumeric chars", () => {
-      // The encoding is intentionally lossy — callers must
-      // disambiguate via session JSONL contents, not dir name.
-      expect(encode("/a/b_c")).toBe(encode("/a/b-c"));
-      expect(encode("/a/b_c")).toBe(encode("/a/b.c"));
-    });
-
-    it("should resolve to a real session dir when cwd contains underscores", () => {
-      const cwd = "/Users/foo/my_project";
-      const expectedDir = path.join(projectsDir, "-Users-foo-my-project");
-      fs.mkdirSync(expectedDir, { recursive: true });
-      const sessionFile = path.join(expectedDir, "session-underscore.jsonl");
-      fs.writeFileSync(sessionFile, "");
-
-      expect(encode(cwd)).toBe(expectedDir);
-      expect(fs.existsSync(path.join(encode(cwd), "session-underscore.jsonl"))).toBe(true);
-    });
-  });
-});

package/src/__tests__/providers/codex/CodexSessionLocator.test.ts

@@ -1,182 +0,0 @@
-import type { MockedFunction } from "vitest";
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import type { ProcessInfo } from "../../../adapters/AgentAdapter.js";
-import { CodexSessionLocator } from "../../../providers/codex/CodexSessionLocator.js";
-import { batchGetSessionFileBirthtimes, type SessionFile } from "../../../utils/session.js";
-import { matchProcessesToSessions, type MatchResult } from "../../../utils/matching.js";
-
-vi.mock("../../../utils/session.js", async () => {
-  const actual = (await vi.importActual(
-    "../../../utils/session",
-  )) as typeof import("../../../utils/session");
-  return {
-    ...actual,
-    batchGetSessionFileBirthtimes: vi.fn(),
-  };
-});
-
-vi.mock("../../../utils/matching.js", async () => {
-  const actual = (await vi.importActual(
-    "../../../utils/matching",
-  )) as typeof import("../../../utils/matching");
-  return {
-    ...actual,
-    matchProcessesToSessions: vi.fn(),
-  };
-});
-
-const mockedBatchGetSessionFileBirthtimes = batchGetSessionFileBirthtimes as MockedFunction<
-  typeof batchGetSessionFileBirthtimes
->;
-const mockedMatchProcessesToSessions = matchProcessesToSessions as MockedFunction<
-  typeof matchProcessesToSessions
->;
-
-describe("CodexSessionLocator", () => {
-  let tmpDir: string;
-  let sessionsDir: string;
-  let locator: CodexSessionLocator;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "codex-locator-"));
-    sessionsDir = path.join(tmpDir, "sessions");
-    locator = new CodexSessionLocator({ sessionsDir });
-    mockedBatchGetSessionFileBirthtimes.mockReset();
-    mockedMatchProcessesToSessions.mockReset();
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("discovers live sessions from the process start day window and applies session_meta cwd and timestamp", () => {
-    const dateDir = path.join(sessionsDir, "2026", "03", "18");
-    fs.mkdirSync(dateDir, { recursive: true });
-    const sessionFile = path.join(dateDir, "sess-meta-time.jsonl");
-    fs.writeFileSync(
-      sessionFile,
-      JSON.stringify({
-        type: "session_meta",
-        payload: { id: "sess-meta-time", timestamp: "2026-03-18T15:00:05.000Z", cwd: "/repo-a" },
-      }),
-    );
-    mockedBatchGetSessionFileBirthtimes.mockReturnValue([
-      {
-        sessionId: "sess-meta-time",
-        filePath: sessionFile,
-        projectDir: dateDir,
-        birthtimeMs: new Date("2026-03-18T15:05:30.000Z").getTime(),
-        resolvedCwd: "",
-      },
-    ]);
-
-    const { sessions, contentCache } = locator.discoverLiveSessions([
-      {
-        pid: 1,
-        command: "codex",
-        cwd: "/repo-a",
-        tty: "",
-        startTime: new Date("2026-03-18T15:00:00Z"),
-      },
-    ]);
-
-    expect(sessions).toHaveLength(1);
-    expect(sessions[0]).toMatchObject({
-      resolvedCwd: "/repo-a",
-      birthtimeMs: new Date("2026-03-18T15:00:05.000Z").getTime(),
-    });
-    expect(contentCache.has(sessionFile)).toBe(true);
-    expect(mockedBatchGetSessionFileBirthtimes.mock.calls[0][0]).toEqual([dateDir]);
-  });
-
-  it("matches resumed UUIDv7 sessions directly without legacy matching", () => {
-    const sessionId = "019eabed-4079-7071-9531-b853ddd9914e";
-    const sessionFile = writeSession(sessionId, "2026/06/09");
-    const processInfo: ProcessInfo = {
-      pid: 88018,
-      command: `codex resume ${sessionId}`,
-      cwd: "/repo-a",
-      tty: "ttys001",
-      startTime: new Date("2026-06-10T12:00:00.000Z"),
-    };
-
-    const result = locator.matchRunningProcesses([processInfo]);
-
-    expect(result.direct).toHaveLength(1);
-    expect(result.direct[0]).toMatchObject({
-      process: processInfo,
-      sessionFile: { sessionId, filePath: sessionFile, resolvedCwd: "/repo-a" },
-    });
-    expect(result.fallback).toEqual([]);
-    expect(mockedBatchGetSessionFileBirthtimes).not.toHaveBeenCalled();
-    expect(mockedMatchProcessesToSessions).not.toHaveBeenCalled();
-  });
-
-  it("falls back to walking all session files for non-time-sortable resume ids", () => {
-    const sessionId = "aaaaaaaa-bbbb-4ccc-dddd-eeeeeeeeeeee";
-    const sessionFile = writeSession(sessionId, "2026/01/02");
-
-    const result = locator.matchRunningProcesses([
-      { pid: 42, command: `codex resume ${sessionId}`, cwd: "/repo-a", tty: "ttys001" },
-    ]);
-
-    expect(result.direct[0].sessionFile.filePath).toBe(sessionFile);
-  });
-
-  it("passes unmatched processes and discovered sessions to legacy matching", () => {
-    const dateDir = path.join(sessionsDir, "2026", "03", "18");
-    fs.mkdirSync(dateDir, { recursive: true });
-    const candidate: SessionFile = {
-      sessionId: "sess",
-      filePath: path.join(dateDir, "sess.jsonl"),
-      projectDir: dateDir,
-      birthtimeMs: new Date("2026-03-18T15:00:05Z").getTime(),
-      resolvedCwd: "",
-    };
-    fs.writeFileSync(
-      candidate.filePath,
-      JSON.stringify({
-        type: "session_meta",
-        payload: { id: "sess", cwd: "/repo-a", timestamp: "2026-03-18T15:00:05Z" },
-      }),
-    );
-    const processInfo: ProcessInfo = {
-      pid: 100,
-      command: "codex",
-      cwd: "/repo-a",
-      tty: "ttys001",
-      startTime: new Date("2026-03-18T15:00:00Z"),
-    };
-    const legacyMatch: MatchResult = {
-      process: processInfo,
-      session: { ...candidate, resolvedCwd: "/repo-a" },
-      deltaMs: 5000,
-    };
-
-    mockedBatchGetSessionFileBirthtimes.mockReturnValue([candidate]);
-    mockedMatchProcessesToSessions.mockReturnValue([legacyMatch]);
-
-    const result = locator.matchRunningProcesses([processInfo]);
-
-    expect(result.direct).toEqual([]);
-    expect(result.fallback).toEqual([processInfo]);
-    expect(result.legacyMatches).toEqual([legacyMatch]);
-    expect(result.contentCache.has(candidate.filePath)).toBe(true);
-  });
-
-  function writeSession(sessionId: string, day: string): string {
-    const dateDir = path.join(sessionsDir, ...day.split("/"));
-    fs.mkdirSync(dateDir, { recursive: true });
-    const sessionFile = path.join(dateDir, `${sessionId}.jsonl`);
-    fs.writeFileSync(
-      sessionFile,
-      JSON.stringify({
-        type: "session_meta",
-        payload: { id: sessionId, timestamp: "2026-03-18T15:00:05.000Z", cwd: "/repo-a" },
-      }),
-    );
-    return sessionFile;
-  }
-});

package/src/__tests__/providers/codex/CodexSessionMapping.test.ts

@@ -1,63 +0,0 @@
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import type { ProcessInfo } from "../../../adapters/AgentAdapter.js";
-import { CodexSessionMapping } from "../../../providers/codex/CodexSessionMapping.js";
-
-describe("CodexSessionMapping", () => {
-  let tmpDir: string;
-  let sessionsDir: string;
-  let mappingPath: string;
-  let processInfo: ProcessInfo;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "codex-mapping-"));
-    sessionsDir = path.join(tmpDir, ".codex", "sessions");
-    mappingPath = path.join(tmpDir, ".codex", "ai-devkit", "sessions.json");
-    processInfo = { pid: 5151, command: "codex", cwd: "/repo", tty: "ttys001" };
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("matches a process to an existing trusted session file", () => {
-    const sessionFile = path.join(sessionsDir, "2026", "06", "26", "session.jsonl");
-    fs.mkdirSync(path.dirname(sessionFile), { recursive: true });
-    fs.mkdirSync(path.dirname(mappingPath), { recursive: true });
-    fs.writeFileSync(sessionFile, "");
-    fs.writeFileSync(mappingPath, JSON.stringify({ 5151: sessionFile }));
-
-    expect(createMapping().match([processInfo])).toEqual({
-      matches: [{ process: processInfo, filePath: sessionFile }],
-      fallback: [],
-    });
-  });
-
-  it("falls back for malformed mappings, missing files, invalid pids, and untrusted paths", () => {
-    fs.mkdirSync(path.dirname(mappingPath), { recursive: true });
-    fs.writeFileSync(
-      mappingPath,
-      JSON.stringify({
-        invalid: path.join(sessionsDir, "ignored.jsonl"),
-        5151: path.join(tmpDir, "outside.jsonl"),
-        9999: path.join(sessionsDir, "missing.jsonl"),
-      }),
-    );
-
-    expect(createMapping().match([processInfo])).toEqual({
-      matches: [],
-      fallback: [processInfo],
-    });
-
-    fs.writeFileSync(mappingPath, "{not-json");
-    expect(createMapping().match([processInfo])).toEqual({
-      matches: [],
-      fallback: [processInfo],
-    });
-  });
-
-  function createMapping(): CodexSessionMapping {
-    return new CodexSessionMapping({ mappingPath, sessionsDir });
-  }
-});