@ai-devkit/agent-manager 0.36.0 → 0.37.0

package/src/__tests__/harnesses/pi/PiDiscoveryIO.test.ts

@@ -0,0 +1,337 @@
+/**
+ * Refresh-path I/O tests for Pi live-session discovery: cost must follow live
+ * processes, not the number of historical Pi session files.
+ */
+
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+import type { ProcessInfo } from "../../../adapters/AgentAdapter.js";
+import { PiAdapter } from "../../../harnesses/pi/PiAdapter.js";
+import { AgentRegistry } from "../../../utils/AgentRegistry.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),
+    readdirSync: vi.fn(actual.readdirSync),
+  };
+});
+
+const mockedOpenSync = vi.mocked(fs.openSync);
+const mockedReadSync = vi.mocked(fs.readSync);
+const mockedReadFileSync = vi.mocked(fs.readFileSync);
+const mockedReaddirSync = vi.mocked(fs.readdirSync);
+
+const HEAD_LIMIT = 64 * 1024;
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+/** 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();
+  mockedReaddirSync.mockClear();
+}
+
+function jsonl(entries: unknown[]): string {
+  return entries.map((entry) => `${JSON.stringify(entry)}\n`).join("");
+}
+
+function encodeProjectDir(cwd: string): string {
+  return `--${cwd.replace(/^\//, "").replace(/\//g, "-")}--`;
+}
+
+/** Pi's session file name for a session created at `createdAt`. */
+function sessionFileName(createdAt: Date, sessionId: string): string {
+  return `${createdAt.toISOString().replace(/[:.]/g, "-")}_${sessionId}.jsonl`;
+}
+
+describe("Pi live discovery I/O", () => {
+  let originalHome: string | undefined;
+  let tmpHome: string;
+  let sessionsDir: string;
+  let adapter: PiAdapter;
+
+  beforeEach(() => {
+    originalHome = process.env.HOME;
+    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "pi-discovery-io-"));
+    process.env.HOME = tmpHome;
+    sessionsDir = path.join(tmpHome, ".pi", "agent", "sessions");
+    fs.mkdirSync(sessionsDir, { recursive: true });
+    adapter = new PiAdapter(new AgentRegistry(path.join(tmpHome, "agents.json")));
+    resetReads();
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    fs.rmSync(tmpHome, { recursive: true, force: true });
+  });
+
+  function writeSession(cwd: string, createdAt: Date, sessionId: string, body = ""): string {
+    const projectDir = path.join(sessionsDir, encodeProjectDir(cwd));
+    fs.mkdirSync(projectDir, { recursive: true });
+    const filePath = path.join(projectDir, sessionFileName(createdAt, sessionId));
+    fs.writeFileSync(
+      filePath,
+      jsonl([
+        {
+          type: "session",
+          version: 3,
+          id: sessionId,
+          timestamp: createdAt.toISOString(),
+          cwd,
+        },
+        {
+          type: "message",
+          timestamp: createdAt.toISOString(),
+          message: {
+            role: "user",
+            content: [{ type: "text", text: `prompt ${sessionId}` }],
+          },
+        },
+      ]) + body,
+    );
+    return filePath;
+  }
+
+  function makeProcess(pid: number, cwd: string, startTime: Date): ProcessInfo {
+    return { pid, command: "pi", cwd, tty: "ttys001", startTime };
+  }
+
+  /** Session files (under the sessions tree) opened or read since the last reset. */
+  function sessionFilesTouched(): string[] {
+    const paths = [
+      ...mockedOpenSync.mock.calls.map((call) => String(call[0])),
+      ...mockedReadFileSync.mock.calls.map((call) => String(call[0])),
+    ];
+    return [...new Set(paths.filter((p) => p.startsWith(sessionsDir + path.sep)))].sort();
+  }
+
+  function sessionBytesRead(): number {
+    return sessionFilesTouched().reduce((sum, filePath) => sum + bytesReadFrom(filePath), 0);
+  }
+
+  it("opens only in-window files of the process project dir, heads only, then nothing", async () => {
+    const liveCwd = "/repo/live-project";
+    const startTime = new Date(Date.now() - 2 * DAY_MS);
+    const proc = makeProcess(4242, liveCwd, startTime);
+
+    // 1,000 historical sessions: 950 in other projects, 49 old ones in the live
+    // project, plus one created right after the process started.
+    let count = 0;
+    for (let project = 0; project < 50; project++) {
+      for (let i = 0; i < 19; i++) {
+        writeSession(
+          `/repo/other-${project}`,
+          new Date(startTime.getTime() + (i - 9) * 1000),
+          `other-${project}-${i}`,
+        );
+        count++;
+      }
+    }
+    for (let i = 0; i < 49; i++) {
+      writeSession(liveCwd, new Date(startTime.getTime() - (i + 1) * DAY_MS), `old-${i}`);
+      count++;
+    }
+    const bigBody = jsonl(
+      Array.from({ length: 2000 }, (_, i) => ({
+        type: "message",
+        timestamp: new Date(startTime.getTime() + i).toISOString(),
+        message: { role: "assistant", content: `reply ${i} ${"x".repeat(80)}` },
+      })),
+    );
+    const inWindow = writeSession(
+      liveCwd,
+      new Date(startTime.getTime() + 10_000),
+      "in-window",
+      bigBody,
+    );
+    count++;
+    expect(count).toBe(1000);
+    expect(fs.statSync(inWindow).size).toBeGreaterThan(HEAD_LIMIT);
+
+    const first = await adapter.detectAgents({ processes: [proc] });
+
+    // Unmatched: the only in-window file's birthtime is "now", not near start
+    expect(first).toHaveLength(1);
+    expect(first[0]).toMatchObject({ pid: 4242, sessionId: "pid-4242" });
+    expect(sessionFilesTouched()).toEqual([inWindow]);
+    expect(
+      mockedReadFileSync.mock.calls.some((c) => String(c[0]).startsWith(sessionsDir + path.sep)),
+    ).toBe(false);
+    expect(bytesReadFrom(inWindow)).toBeGreaterThan(0);
+    expect(bytesReadFrom(inWindow)).toBeLessThanOrEqual(HEAD_LIMIT);
+    // Only the live project dir is listed, never the whole history tree
+    const listed = mockedReaddirSync.mock.calls
+      .map((c) => String(c[0]))
+      .filter((p) => p.startsWith(sessionsDir + path.sep));
+    expect(listed).toEqual([path.join(sessionsDir, encodeProjectDir(liveCwd))]);
+
+    resetReads();
+    const second = await adapter.detectAgents({ processes: [proc] });
+
+    expect(second).toEqual([expect.objectContaining({ pid: 4242, sessionId: "pid-4242" })]);
+    expect(sessionFilesTouched()).toEqual([]);
+    expect(sessionBytesRead()).toBe(0);
+    expect(
+      mockedReaddirSync.mock.calls.some((c) => String(c[0]).startsWith(sessionsDir + path.sep)),
+    ).toBe(false);
+  });
+
+  it("re-checks a no-match project dir when a session file is added", async () => {
+    const cwd = "/repo/added-later";
+    const startTime = new Date(Date.now() - 2 * DAY_MS);
+    const proc = makeProcess(5151, cwd, startTime);
+    writeSession(cwd, new Date(startTime.getTime() - DAY_MS), "stale");
+
+    await adapter.detectAgents({ processes: [proc] });
+    expect(sessionFilesTouched()).toEqual([]);
+
+    resetReads();
+    await adapter.detectAgents({ processes: [proc] });
+    expect(mockedReaddirSync).not.toHaveBeenCalledWith(
+      path.join(sessionsDir, encodeProjectDir(cwd)),
+    );
+
+    const added = writeSession(cwd, new Date(startTime.getTime() + 5_000), "added");
+    resetReads();
+    await adapter.detectAgents({ processes: [proc] });
+
+    expect(sessionFilesTouched()).toEqual([added]);
+    expect(bytesReadFrom(added)).toBeLessThanOrEqual(HEAD_LIMIT);
+  });
+
+  it("re-checks a no-match project dir when a new process needs it", async () => {
+    const cwd = "/repo/new-process";
+    const oldStart = new Date(Date.now() - 2 * DAY_MS);
+    await adapter.detectAgents({
+      processes: [makeProcess(6161, cwd, oldStart)],
+    });
+
+    const sessionFile = writeSession(cwd, new Date(), "fresh");
+    const oldProc = makeProcess(6161, cwd, oldStart);
+    await adapter.detectAgents({ processes: [oldProc] });
+
+    // A new process started now must still be matched to the fresh session
+    const agents = await adapter.detectAgents({
+      processes: [oldProc, makeProcess(6262, cwd, new Date())],
+    });
+    expect(agents).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          pid: 6262,
+          sessionId: "fresh",
+          sessionFilePath: sessionFile,
+        }),
+        expect.objectContaining({ pid: 6161, sessionId: "pid-6161" }),
+      ]),
+    );
+  });
+
+  it("hands a session to the losing rival once the matched process exits", async () => {
+    const cwd = "/repo/rivals";
+    const now = Date.now();
+    const sessionFile = writeSession(cwd, new Date(now), "shared");
+    const winner = makeProcess(7171, cwd, new Date(now));
+    const loser = makeProcess(7272, cwd, new Date(now + 60_000));
+
+    const both = await adapter.detectAgents({ processes: [winner, loser] });
+    expect(both).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ pid: 7171, sessionId: "shared" }),
+        expect.objectContaining({ pid: 7272, sessionId: "pid-7272" }),
+      ]),
+    );
+
+    const alone = await adapter.detectAgents({ processes: [loser] });
+    expect(alone).toEqual([
+      expect.objectContaining({
+        pid: 7272,
+        sessionId: "shared",
+        sessionFilePath: sessionFile,
+      }),
+    ]);
+  });
+
+  it("reads 0 bytes of an unchanged matched session and only appended bytes after growth", async () => {
+    const cwd = "/repo/matched";
+    const now = new Date();
+    const sessionFile = writeSession(cwd, now, "matched-session");
+    const proc = makeProcess(8181, cwd, now);
+
+    const first = await adapter.detectAgents({ processes: [proc] });
+    expect(first).toEqual([
+      expect.objectContaining({
+        pid: 8181,
+        sessionId: "matched-session",
+        summary: "prompt matched-session",
+      }),
+    ]);
+
+    resetReads();
+    await adapter.detectAgents({ processes: [proc] });
+    expect(sessionBytesRead()).toBe(0);
+
+    const appended = jsonl([
+      {
+        type: "message",
+        timestamp: new Date().toISOString(),
+        message: { role: "user", content: "follow-up prompt" },
+      },
+    ]);
+    fs.appendFileSync(sessionFile, appended);
+    resetReads();
+    const third = await adapter.detectAgents({ processes: [proc] });
+
+    expect(third).toEqual([expect.objectContaining({ pid: 8181, summary: "follow-up prompt" })]);
+    expect(bytesReadFrom(sessionFile)).toBe(Buffer.byteLength(appended));
+  });
+
+  it("serves tracker-matched sessions from the incremental cache", async () => {
+    const cwd = "/repo/tracked";
+    const sessionFile = writeSession(cwd, new Date(), "tracked-session");
+    fs.writeFileSync(
+      path.join(tmpHome, ".pi", "agent", "sessions.json"),
+      JSON.stringify({ 9191: sessionFile }),
+    );
+    const proc = makeProcess(9191, cwd, new Date(Date.now() - DAY_MS));
+
+    await adapter.detectAgents({ processes: [proc] });
+    resetReads();
+    const agents = await adapter.detectAgents({ processes: [proc] });
+
+    expect(agents).toEqual([expect.objectContaining({ sessionId: "tracked-session" })]);
+    expect(bytesReadFrom(sessionFile)).toBe(0);
+  });
+});

package/src/__tests__/{providers → harnesses}/pi/PiSessionParser.test.ts

@@ -3,7 +3,7 @@ import * as os from "os";
 import * as path from "path";
 
 import { AgentStatus } from "../../../adapters/AgentAdapter.js";
-import { PiSessionParser } from "../../../providers/pi/PiSessionParser.js";
+import { PiSessionParser } from "../../../harnesses/pi/PiSessionParser.js";
 
 describe("PiSessionParser", () => {
   let tmpDir: string;
@@ -177,6 +177,96 @@ describe("PiSessionParser", () => {
     });
   });
 
+  describe("readSessionIncremental", () => {
+    const fixtures: Array<Array<Record<string, unknown> | string>> = [
+      [
+        { type: "session", id: "sess-a", timestamp: "2026-06-10T08:58:20.754Z", cwd: "/repo/a" },
+        { role: "system", timestamp: "2026-06-10T08:58:21.000Z", content: "model changed" },
+        { role: "user", timestamp: "2026-06-10T08:58:22.000Z", content: "first" },
+        { role: "assistant", timestamp: "2026-06-10T08:58:23.000Z", content: "reply" },
+        { role: "user", timestamp: "bad-date", content: "x".repeat(200) },
+        { role: "system", content: "trailing system" },
+      ],
+      [{ role: "user", content: "no timestamps or id" }, "{not json", "[1,2]", "42"],
+      [
+        {
+          payload: { sessionId: "nested", cwd: "/repo/nested", timestamp: "2026-06-10T08:00:00Z" },
+        },
+        { data: { role: "assistant", content: [{ type: "text", text: "nested reply" }] } },
+      ],
+      ["{not json", "   "],
+    ];
+
+    it.each(fixtures.map((entries, index) => [index, entries] as const))(
+      "matches readSession for fixture %i",
+      (_index, entries) => {
+        const filePath = writeJsonl("equivalence.jsonl", entries);
+        expect(parser.readSessionIncremental(filePath, "/fallback")).toEqual(
+          parser.readSession(filePath, "/fallback"),
+        );
+      },
+    );
+
+    it("folds appended lines into the cached summary", () => {
+      const filePath = writeJsonl("append.jsonl", [
+        { type: "session", id: "sess-append", timestamp: "2026-06-10T08:58:20.754Z", cwd: "/r" },
+        { role: "user", timestamp: "2026-06-10T08:58:21.000Z", content: "before" },
+      ]);
+      expect(parser.readSessionIncremental(filePath)?.summary).toBe("before");
+
+      const next = { role: "user", timestamp: "2026-06-10T09:00:00.000Z", content: "after" };
+      fs.appendFileSync(filePath, `\n${JSON.stringify(next)}\n`);
+
+      const session = parser.readSessionIncremental(filePath);
+      expect(session).toEqual(parser.readSession(filePath));
+      expect(session).toMatchObject({ summary: "after", sessionId: "sess-append" });
+    });
+  });
+
+  describe("readSessionHead", () => {
+    it("stops reading once the header gives session id and cwd", () => {
+      const filePath = writeJsonl("head.jsonl", [
+        { type: "session", id: "sess-head", timestamp: "2026-06-10T08:58:20.754Z", cwd: "/repo/h" },
+        ...Array.from({ length: 5000 }, (_, i) => ({ role: "assistant", content: `line ${i}` })),
+      ]);
+
+      const head = parser.readSessionHead(filePath);
+
+      expect(head).toMatchObject({ sessionId: "sess-head", projectPath: "/repo/h" });
+      expect(head?.complete).toBe(false);
+      expect(head!.bytesRead).toBeLessThanOrEqual(4 * 1024);
+    });
+
+    it("never reads more than the byte cap", () => {
+      const filePath = writeJsonl(
+        "no-header.jsonl",
+        Array.from({ length: 5000 }, (_, i) => ({ role: "assistant", content: `line ${i}` })),
+      );
+      expect(fs.statSync(filePath).size).toBeGreaterThan(64 * 1024);
+
+      expect(parser.readSessionHead(filePath)).toEqual({ bytesRead: 64 * 1024, complete: false });
+      expect(parser.readSessionHead(filePath, 1000)?.bytesRead).toBe(1000);
+    });
+
+    it("uses an unterminated last line only when it ends the file", () => {
+      const whole = writeJsonl("whole.jsonl", [{ id: "sess-whole", cwd: "/repo/whole" }]);
+      expect(parser.readSessionHead(whole)).toMatchObject({
+        sessionId: "sess-whole",
+        projectPath: "/repo/whole",
+        complete: true,
+      });
+
+      const cut = writeJsonl("cut.jsonl", [
+        { id: "sess-cut", cwd: "/repo/cut", pad: "y".repeat(50) },
+      ]);
+      expect(parser.readSessionHead(cut, 20)).toEqual({ bytesRead: 20, complete: false });
+    });
+
+    it("returns null for a missing file", () => {
+      expect(parser.readSessionHead(path.join(tmpDir, "missing.jsonl"))).toBeNull();
+    });
+  });
+
   function writeJsonl(name: string, entries: Array<Record<string, unknown> | string>): string {
     const filePath = path.join(tmpDir, name);
     fs.writeFileSync(

package/src/__tests__/{providers → harnesses}/pi/PiSessionTracker.test.ts

@@ -3,7 +3,7 @@ import * as os from "os";
 import * as path from "path";
 
 import type { ProcessInfo } from "../../../adapters/AgentAdapter.js";
-import { PiSessionTracker } from "../../../providers/pi/PiSessionTracker.js";
+import { PiSessionTracker } from "../../../harnesses/pi/PiSessionTracker.js";
 
 describe("PiSessionTracker", () => {
   let tmpHome: string;

package/src/__tests__/{providers → harnesses}/pi/durable/PiPrintProtocol.test.ts

@@ -3,7 +3,7 @@ import {
   buildPiPrintArgs,
   readPiAssistantText,
   readPiSessionId,
-} from "../../../../providers/pi/durable/PiPrintProtocol.js";
+} from "../../../../harnesses/pi/durable/PiPrintProtocol.js";
 
 const SESSION = "22222222-2222-4222-8222-222222222222";
 

package/src/__tests__/{providers → harnesses}/pi/durable/PiStreamParser.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { PiStreamParser } from "../../../../providers/pi/durable/PiStreamParser.js";
+import { PiStreamParser } from "../../../../harnesses/pi/durable/PiStreamParser.js";
 
 const SESSION = "22222222-2222-4222-8222-222222222222";
 

package/src/__tests__/readiness/AgentReadiness.test.ts

@@ -137,6 +137,22 @@ describe("agent readiness", () => {
     expect(reports.opencode.integration).toBeUndefined();
   });
 
+  it("resolves agent executables from PATH directories containing spaces", async () => {
+    const spacedBin = "/Applications/Some App.app/Contents/Resources";
+    const codexPath = path.join(spacedBin, AGENTS.codex.command);
+    const { options } = fixture({
+      path: [spacedBin, "/usr/local/bin"].join(path.delimiter),
+      access: async (target) => {
+        if (target === codexPath || target.startsWith("/home/test")) return;
+        throw new Error("missing");
+      },
+    });
+
+    const report = await getAgentReadinessReport("codex", options);
+
+    expect(report.executable).toMatchObject({ command: "codex", path: codexPath, status: "pass" });
+  });
+
   it("parses Pi provider names without returning credential values", async () => {
     const { options } = fixture();
 

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

@@ -1,3 +1,6 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
 import {
   AgentNameInUseError,
   AgentPidPollTimeoutError,
@@ -451,6 +454,33 @@ describe("startAgent", () => {
     expect(tmux.createSession).not.toHaveBeenCalled();
   });
 
+  it("detects the agent PID when the agent is installed under a path containing spaces", async () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "managed-runtime-spaces-"));
+    try {
+      const codexPath = path.join(root, "Applications/Some App.app/Contents/Resources/codex");
+      fs.mkdirSync(path.dirname(codexPath), { recursive: true });
+      fs.writeFileSync(codexPath, "");
+      const processTree = [
+        { pid: 100, command: "-zsh" },
+        { pid: 200, command: `${codexPath} --sandbox workspace-write` },
+        { pid: 300, command: "/usr/local/bin/node /opt/mcp/server.js" },
+      ];
+      const findAgentPid = vi.fn(
+        async (_session: string, matches: (psCommand: string) => boolean) =>
+          processTree.filter((proc) => matches(proc.command)).at(-1)?.pid ?? null,
+      );
+      const tmux = makeTmux({ findAgentPid } as Partial<TmuxManager>);
+      const registry = makeRegistry();
+
+      const entry = await startAgent({ ...startOpts, type: "codex" }, { tmux, registry });
+
+      expect(tmux.sendKeys).toHaveBeenCalledWith("agent1", "codex");
+      expect(entry).toMatchObject({ type: "codex", pid: 200 });
+    } finally {
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+  });
+
   it("replaces orphan tmux session and calls onWarning", async () => {
     const tmux = makeTmux({
       sessionExists: vi.fn().mockResolvedValue(true),