@posthog/agent 2.3.510 → 2.3.517

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/agent",
-  "version": "2.3.510",
+  "version": "2.3.517",
   "repository": "https://github.com/PostHog/code",
   "description": "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   "exports": {
@@ -102,9 +102,9 @@
     "tsx": "^4.20.6",
     "typescript": "^5.5.0",
     "vitest": "^2.1.8",
-    "@posthog/shared": "1.0.0",
     "@posthog/git": "1.0.0",
-    "@posthog/enricher": "1.0.0"
+    "@posthog/enricher": "1.0.0",
+    "@posthog/shared": "1.0.0"
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "0.19.0",

package/src/adapters/claude/session/mcp-config.test.ts

@@ -0,0 +1,112 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { loadUserClaudeJsonMcpServers } from "./mcp-config";
+
+describe("loadUserClaudeJsonMcpServers", () => {
+  let tmpHome: string;
+
+  beforeEach(() => {
+    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "claude-json-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpHome, { recursive: true, force: true });
+  });
+
+  it.each([
+    { name: "~/.claude.json is missing", setup: () => undefined },
+    {
+      name: "~/.claude.json contains invalid JSON",
+      setup: (home: string) =>
+        fs.writeFileSync(path.join(home, ".claude.json"), "not json"),
+    },
+  ])("returns empty when $name", ({ setup }) => {
+    setup(tmpHome);
+    expect(
+      loadUserClaudeJsonMcpServers("/some/cwd", undefined, tmpHome),
+    ).toEqual({});
+  });
+
+  it("returns top-level mcpServers", () => {
+    const cfg = {
+      mcpServers: {
+        top: { type: "stdio", command: "npx", args: ["pkg"] },
+      },
+    };
+    fs.writeFileSync(path.join(tmpHome, ".claude.json"), JSON.stringify(cfg));
+    const servers = loadUserClaudeJsonMcpServers(
+      "/some/cwd",
+      undefined,
+      tmpHome,
+    );
+    expect(servers.top).toBeDefined();
+  });
+
+  it("returns project-scoped mcpServers when cwd matches a project entry", () => {
+    const cwd = "/Users/jane/proj";
+    const cfg = {
+      projects: {
+        [cwd]: {
+          mcpServers: {
+            playwright: {
+              type: "stdio",
+              command: "npx",
+              args: ["@playwright/mcp@latest"],
+            },
+          },
+        },
+      },
+    };
+    fs.writeFileSync(path.join(tmpHome, ".claude.json"), JSON.stringify(cfg));
+    const servers = loadUserClaudeJsonMcpServers(cwd, undefined, tmpHome);
+    expect(servers.playwright).toBeDefined();
+  });
+
+  it("project-scoped servers override top-level on key collision", () => {
+    const cwd = "/Users/jane/proj";
+    const cfg = {
+      mcpServers: {
+        shared: { type: "stdio", command: "global", args: [] },
+      },
+      projects: {
+        [cwd]: {
+          mcpServers: {
+            shared: { type: "stdio", command: "scoped", args: [] },
+          },
+        },
+      },
+    };
+    fs.writeFileSync(path.join(tmpHome, ".claude.json"), JSON.stringify(cfg));
+    const servers = loadUserClaudeJsonMcpServers(cwd, undefined, tmpHome);
+    expect((servers.shared as { command: string }).command).toBe("scoped");
+  });
+
+  it("ignores CLAUDE_CONFIG_DIR redirect (reads real ~/.claude.json)", () => {
+    const altDir = fs.mkdtempSync(path.join(os.tmpdir(), "alt-claude-"));
+    fs.writeFileSync(
+      path.join(altDir, ".claude.json"),
+      JSON.stringify({
+        mcpServers: { wrong: { type: "stdio", command: "x" } },
+      }),
+    );
+    fs.writeFileSync(
+      path.join(tmpHome, ".claude.json"),
+      JSON.stringify({
+        mcpServers: { right: { type: "stdio", command: "y" } },
+      }),
+    );
+    const original = process.env.CLAUDE_CONFIG_DIR;
+    process.env.CLAUDE_CONFIG_DIR = altDir;
+    try {
+      const servers = loadUserClaudeJsonMcpServers("/cwd", undefined, tmpHome);
+      expect(servers.right).toBeDefined();
+      expect(servers.wrong).toBeUndefined();
+    } finally {
+      if (original === undefined) delete process.env.CLAUDE_CONFIG_DIR;
+      else process.env.CLAUDE_CONFIG_DIR = original;
+      fs.rmSync(altDir, { recursive: true, force: true });
+    }
+  });
+});

package/src/adapters/claude/session/mcp-config.ts

@@ -1,5 +1,50 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
 import type { NewSessionRequest } from "@agentclientprotocol/sdk";
 import type { McpServerConfig } from "@anthropic-ai/claude-agent-sdk";
+import type { Logger } from "../../../utils/logger";
+
+export function loadUserClaudeJsonMcpServers(
+  cwd: string,
+  logger?: Logger,
+  homeDir: string = os.homedir(),
+): Record<string, McpServerConfig> {
+  const claudeJsonPath = path.join(homeDir, ".claude.json");
+
+  let raw: string;
+  try {
+    raw = fs.readFileSync(claudeJsonPath, "utf8");
+  } catch {
+    return {};
+  }
+
+  let cfg: {
+    mcpServers?: unknown;
+    projects?: Record<string, { mcpServers?: unknown }>;
+  };
+  try {
+    cfg = JSON.parse(raw);
+  } catch (err) {
+    logger?.warn("Failed to parse ~/.claude.json", {
+      error: err instanceof Error ? err.message : String(err),
+    });
+    return {};
+  }
+
+  const topLevel =
+    cfg.mcpServers && typeof cfg.mcpServers === "object"
+      ? (cfg.mcpServers as Record<string, McpServerConfig>)
+      : {};
+
+  const project = cfg.projects?.[cwd];
+  const projectScoped =
+    project?.mcpServers && typeof project.mcpServers === "object"
+      ? (project.mcpServers as Record<string, McpServerConfig>)
+      : {};
+
+  return { ...topLevel, ...projectScoped };
+}
 
 export function parseMcpServers(
   params: Pick<NewSessionRequest, "mcpServers">,

package/src/adapters/claude/session/options.ts

@@ -24,6 +24,7 @@ import {
 import type { CodeExecutionMode } from "../tools";
 import type { EffortLevel } from "../types";
 import { APPENDED_INSTRUCTIONS } from "./instructions";
+import { loadUserClaudeJsonMcpServers } from "./mcp-config";
 import { DEFAULT_MODEL } from "./models";
 import type { SettingsManager } from "./settings";
 
@@ -91,8 +92,10 @@ export function buildSystemPrompt(
 function buildMcpServers(
   userServers: Record<string, McpServerConfig> | undefined,
   acpServers: Record<string, McpServerConfig>,
+  projectScopedServers: Record<string, McpServerConfig>,
 ): Record<string, McpServerConfig> {
   return {
+    ...projectScopedServers,
     ...(userServers || {}),
     ...acpServers,
   };
@@ -330,6 +333,7 @@ export function buildSessionOptions(params: BuildOptionsParams): Options {
     mcpServers: buildMcpServers(
       params.userProvidedOptions?.mcpServers,
       params.mcpServers,
+      loadUserClaudeJsonMcpServers(params.cwd, params.logger),
     ),
     env: buildEnvironment(),
     hooks: buildHooks(

package/src/server/agent-server.test.ts

@@ -13,7 +13,7 @@ import {
 import { createTestRepo, type TestRepo } from "../test/fixtures/api";
 import { createPostHogHandlers } from "../test/mocks/msw-handlers";
 import type { TaskRun } from "../types";
-import { AgentServer } from "./agent-server";
+import { AgentServer, SSE_KEEPALIVE_INTERVAL_MS } from "./agent-server";
 import { type JwtPayload, SANDBOX_CONNECTION_AUDIENCE } from "./jwt";
 
 interface TestableServer {
@@ -274,6 +274,64 @@ describe("AgentServer HTTP Mode", () => {
       expect(response.status).toBe(200);
       expect(response.headers.get("content-type")).toBe("text/event-stream");
     }, 20000);
+
+    it("emits transport keepalive comments while idle", async () => {
+      const keepaliveCallback: { current: (() => void) | null } = {
+        current: null,
+      };
+      const setIntervalSpy = vi
+        .spyOn(globalThis, "setInterval")
+        .mockImplementation(
+          (callback: (_: undefined) => void, timeout?: number) => {
+            if (timeout === SSE_KEEPALIVE_INTERVAL_MS) {
+              keepaliveCallback.current = () => callback(undefined);
+            }
+            return setTimeout(() => undefined, 60_000);
+          },
+        );
+
+      let reader: ReadableStreamDefaultReader<Uint8Array> | null = null;
+      try {
+        await createServer().start();
+        const token = createToken();
+
+        const response = await fetch(`http://localhost:${port}/events`, {
+          headers: { Authorization: `Bearer ${token}` },
+        });
+
+        expect(response.status).toBe(200);
+        expect(response.body).not.toBeNull();
+        reader = response.body?.getReader() ?? null;
+        expect(reader).not.toBeNull();
+        if (!reader) {
+          throw new Error("Expected SSE response body reader");
+        }
+
+        await vi.waitFor(() =>
+          expect(keepaliveCallback.current).not.toBeNull(),
+        );
+        const emitKeepalive = keepaliveCallback.current;
+        if (!emitKeepalive) {
+          throw new Error("Expected keepalive callback to be registered");
+        }
+        emitKeepalive();
+
+        const decoder = new TextDecoder();
+        let streamText = "";
+        for (let attempts = 0; attempts < 5; attempts++) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          streamText += decoder.decode(value, { stream: true });
+          if (streamText.includes(": keepalive\n\n")) break;
+        }
+
+        expect(streamText).toContain(": keepalive\n\n");
+        expect(streamText).not.toContain('"type":"keepalive"');
+      } finally {
+        await reader?.cancel();
+        setIntervalSpy.mockRestore();
+      }
+    }, 20000);
   });
 
   describe("POST /command", () => {

package/src/server/agent-server.ts

@@ -73,6 +73,8 @@ const errorWithClassificationSchema = z.object({
 
 type MessageCallback = (message: unknown) => void;
 
+export const SSE_KEEPALIVE_INTERVAL_MS = 25_000;
+
 class NdJsonTap {
   private decoder = new TextDecoder();
   private buffer = "";
@@ -329,41 +331,73 @@ export class AgentServer {
         );
       }
 
+      let keepaliveInterval: ReturnType<typeof setInterval> | null = null;
+      const clearKeepalive = (): void => {
+        if (keepaliveInterval) {
+          clearInterval(keepaliveInterval);
+          keepaliveInterval = null;
+        }
+      };
+
       const stream = new ReadableStream({
         start: async (controller) => {
-          const sseController: SseController = {
+          let sseController: SseController | null = null;
+          const encoder = new TextEncoder();
+          const detachCurrentSseController = (): void => {
+            if (sseController) {
+              this.detachSseController(sseController);
+            }
+          };
+          const enqueueSseFrame = (frame: string): void => {
+            try {
+              controller.enqueue(encoder.encode(frame));
+            } catch {
+              clearKeepalive();
+              detachCurrentSseController();
+            }
+          };
+
+          sseController = {
             send: (data: unknown) => {
-              try {
-                controller.enqueue(
-                  new TextEncoder().encode(`data: ${JSON.stringify(data)}\n\n`),
-                );
-              } catch {
-                this.detachSseController(sseController);
-              }
+              enqueueSseFrame(`data: ${JSON.stringify(data)}\n\n`);
             },
             close: () => {
               try {
+                clearKeepalive();
                 controller.close();
               } catch {
-                this.detachSseController(sseController);
+                detachCurrentSseController();
               }
             },
           };
 
-          if (!this.session || this.session.payload.run_id !== payload.run_id) {
-            await this.initializeSession(payload, sseController);
-          } else {
-            this.session.sseController = sseController;
-            this.session.hasDesktopConnected = true;
-            this.replayPendingEvents();
-          }
+          keepaliveInterval = setInterval(() => {
+            enqueueSseFrame(": keepalive\n\n");
+          }, SSE_KEEPALIVE_INTERVAL_MS);
+
+          try {
+            if (
+              !this.session ||
+              this.session.payload.run_id !== payload.run_id
+            ) {
+              await this.initializeSession(payload, sseController);
+            } else {
+              this.session.sseController = sseController;
+              this.session.hasDesktopConnected = true;
+              this.replayPendingEvents();
+            }
 
-          this.sendSseEvent(sseController, {
-            type: "connected",
-            run_id: payload.run_id,
-          });
+            this.sendSseEvent(sseController, {
+              type: "connected",
+              run_id: payload.run_id,
+            });
+          } catch (error) {
+            clearKeepalive();
+            throw error;
+          }
         },
         cancel: () => {
+          clearKeepalive();
           this.logger.debug("SSE connection closed");
           if (this.session?.sseController) {
             this.session.sseController = null;