@posthog/agent 2.1.150 → 2.1.156

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/agent",
-  "version": "2.1.150",
+  "version": "2.1.156",
   "repository": "https://github.com/PostHog/twig",
   "description": "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   "exports": {
@@ -74,8 +74,8 @@
     "tsx": "^4.20.6",
     "typescript": "^5.5.0",
     "vitest": "^2.1.8",
-    "@twig/git": "1.0.0",
-    "@posthog/shared": "1.0.0"
+    "@posthog/shared": "1.0.0",
+    "@twig/git": "1.0.0"
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "^0.14.0",

package/src/adapters/claude/conversion/sdk-to-acp.ts

@@ -192,6 +192,7 @@ function handleToolUseChunk(
   const toolInfo = toolInfoFromToolUse(chunk, {
     supportsTerminalOutput: ctx.supportsTerminalOutput,
     toolUseId: chunk.id,
+    cachedFileContent: ctx.fileContentCache,
   });
 
   const meta: Record<string, unknown> = {
@@ -221,6 +222,66 @@ function handleToolUseChunk(
   };
 }
 
+function extractTextFromContent(content: unknown): string | null {
+  if (Array.isArray(content)) {
+    const parts: string[] = [];
+    for (const item of content) {
+      if (
+        typeof item === "object" &&
+        item !== null &&
+        "text" in item &&
+        typeof (item as Record<string, unknown>).text === "string"
+      ) {
+        parts.push((item as { text: string }).text);
+      }
+    }
+    return parts.length > 0 ? parts.join("") : null;
+  }
+  if (typeof content === "string") {
+    return content;
+  }
+  return null;
+}
+
+function stripCatLineNumbers(text: string): string {
+  return text.replace(/^ *\d+[\t→]/gm, "");
+}
+
+function updateFileContentCache(
+  toolUse: { name: string; input: unknown },
+  chunk: { content?: unknown },
+  ctx: ChunkHandlerContext,
+): void {
+  const input = toolUse.input as Record<string, unknown> | undefined;
+  const filePath = input?.file_path ? String(input.file_path) : undefined;
+  if (!filePath) return;
+
+  if (toolUse.name === "Read" && !input?.limit && !input?.offset) {
+    const fileText = extractTextFromContent(chunk.content);
+    if (fileText !== null) {
+      ctx.fileContentCache[filePath] = stripCatLineNumbers(fileText);
+    }
+  } else if (toolUse.name === "Write") {
+    const content = input?.content;
+    if (typeof content === "string") {
+      ctx.fileContentCache[filePath] = content;
+    }
+  } else if (toolUse.name === "Edit") {
+    const oldString = input?.old_string;
+    const newString = input?.new_string;
+    if (
+      typeof oldString === "string" &&
+      typeof newString === "string" &&
+      filePath in ctx.fileContentCache
+    ) {
+      const current = ctx.fileContentCache[filePath];
+      ctx.fileContentCache[filePath] = input?.replace_all
+        ? current.replaceAll(oldString, newString)
+        : current.replace(oldString, newString);
+    }
+  }
+}
+
 function handleToolResultChunk(
   chunk: AnthropicContentChunk & {
     tool_use_id: string;
@@ -241,12 +302,17 @@ function handleToolResultChunk(
     return [];
   }
 
+  if (!chunk.is_error) {
+    updateFileContentCache(toolUse, chunk, ctx);
+  }
+
   const { _meta: resultMeta, ...toolUpdate } = toolUpdateFromToolResult(
     chunk as Parameters<typeof toolUpdateFromToolResult>[0],
     toolUse,
     {
       supportsTerminalOutput: ctx.supportsTerminalOutput,
       toolUseId: chunk.tool_use_id,
+      cachedFileContent: ctx.fileContentCache,
     },
   );
 

package/src/adapters/claude/conversion/tool-use-to-acp.ts

@@ -34,7 +34,11 @@ type ToolInfo = Pick<ToolCall, "title" | "kind" | "content" | "locations">;
 
 export function toolInfoFromToolUse(
   toolUse: Pick<ToolUseBlock, "name" | "input">,
-  options?: { supportsTerminalOutput?: boolean; toolUseId?: string },
+  options?: {
+    supportsTerminalOutput?: boolean;
+    toolUseId?: string;
+    cachedFileContent?: Record<string, string>;
+  },
 ): ToolInfo {
   const name = toolUse.name;
   const input = toolUse.input as Record<string, unknown> | undefined;
@@ -144,8 +148,24 @@ export function toolInfoFromToolUse(
 
     case "Edit": {
       const path = input?.file_path ? String(input.file_path) : undefined;
-      const oldText = input?.old_string ? String(input.old_string) : null;
-      const newText = input?.new_string ? String(input.new_string) : "";
+      let oldText: string | null = input?.old_string
+        ? String(input.old_string)
+        : null;
+      let newText: string = input?.new_string ? String(input.new_string) : "";
+
+      // If we have cached file content, show a full-file diff
+      if (
+        path &&
+        options?.cachedFileContent &&
+        path in options.cachedFileContent
+      ) {
+        const oldContent = options.cachedFileContent[path];
+        const newContent = input?.replace_all
+          ? oldContent.replaceAll(oldText ?? "", newText)
+          : oldContent.replace(oldText ?? "", newText);
+        oldText = oldContent;
+        newText = newContent;
+      }
 
       return {
         title: path ? `Edit \`${path}\`` : "Edit",
@@ -170,8 +190,12 @@ export function toolInfoFromToolUse(
       const filePath = input?.file_path ? String(input.file_path) : undefined;
       const contentStr = input?.content ? String(input.content) : undefined;
       if (filePath) {
+        const oldContent =
+          options?.cachedFileContent && filePath in options.cachedFileContent
+            ? options.cachedFileContent[filePath]
+            : null;
         contentResult = toolContent()
-          .diff(filePath, null, contentStr ?? "")
+          .diff(filePath, oldContent, contentStr ?? "")
           .build();
       } else if (contentStr) {
         contentResult = toolContent().text(contentStr).build();
@@ -453,7 +477,11 @@ export function toolUpdateFromToolResult(
     | BetaRequestMCPToolResultBlockParam
     | BetaToolSearchToolResultBlockParam,
   toolUse: Pick<ToolUseBlock, "name" | "input"> | undefined,
-  options?: { supportsTerminalOutput?: boolean; toolUseId?: string },
+  options?: {
+    supportsTerminalOutput?: boolean;
+    toolUseId?: string;
+    cachedFileContent?: Record<string, string>;
+  },
 ): Pick<ToolCallUpdate, "title" | "content" | "locations" | "_meta"> {
   if (
     "is_error" in toolResult &&

package/src/server/agent-server.ts

@@ -17,6 +17,7 @@ import { TreeTracker } from "../tree-tracker.js";
 import type {
   AgentMode,
   DeviceInfo,
+  LogLevel,
   TaskRun,
   TreeSnapshotEvent,
 } from "../types.js";
@@ -155,6 +156,35 @@ export class AgentServer {
   private questionRelayedToSlack = false;
   private detectedPrUrl: string | null = null;
 
+  private emitConsoleLog = (
+    level: LogLevel,
+    _scope: string,
+    message: string,
+    data?: unknown,
+  ): void => {
+    if (!this.session) return;
+
+    const formatted =
+      data !== undefined ? `${message} ${JSON.stringify(data)}` : message;
+
+    const notification = {
+      jsonrpc: "2.0",
+      method: POSTHOG_NOTIFICATIONS.CONSOLE,
+      params: { level, message: formatted },
+    };
+
+    this.broadcastEvent({
+      type: "notification",
+      timestamp: new Date().toISOString(),
+      notification,
+    });
+
+    this.session.logWriter.appendRawLine(
+      this.session.payload.run_id,
+      JSON.stringify(notification),
+    );
+  };
+
   constructor(config: AgentServerConfig) {
     this.config = config;
     this.logger = new Logger({ debug: true, prefix: "[AgentServer]" });
@@ -565,7 +595,7 @@ export class AgentServer {
 
     const sessionResponse = await clientConnection.newSession({
       cwd: this.config.repositoryPath,
-      mcpServers: [],
+      mcpServers: this.config.mcpServers ?? [],
       _meta: {
         sessionId: payload.run_id,
         taskRunId: payload.run_id,
@@ -590,6 +620,17 @@ export class AgentServer {
       logWriter,
     };
 
+    this.logger = new Logger({
+      debug: true,
+      prefix: "[AgentServer]",
+      onLog: (level, scope, message, data) => {
+        // Preserve console output (onLog suppresses default console.*)
+        const _formatted =
+          data !== undefined ? `${message} ${JSON.stringify(data)}` : message;
+        this.emitConsoleLog(level, scope, message, data);
+      },
+    });
+
     this.logger.info("Session initialized successfully");
 
     // Signal in_progress so the UI can start polling for updates
@@ -1103,15 +1144,29 @@ Important:
           ...snapshot,
           device: this.session.deviceInfo,
         };
+
+        const notification = {
+          jsonrpc: "2.0" as const,
+          method: POSTHOG_NOTIFICATIONS.TREE_SNAPSHOT,
+          params: snapshotWithDevice,
+        };
+
         this.broadcastEvent({
           type: "notification",
           timestamp: new Date().toISOString(),
-          notification: {
-            jsonrpc: "2.0",
-            method: POSTHOG_NOTIFICATIONS.TREE_SNAPSHOT,
-            params: snapshotWithDevice,
-          },
+          notification,
         });
+
+        // Persist to log writer so cloud runs have tree snapshots
+        const { archiveUrl: _, ...paramsWithoutArchive } = snapshotWithDevice;
+        const logNotification = {
+          ...notification,
+          params: paramsWithoutArchive,
+        };
+        this.session.logWriter.appendRawLine(
+          this.session.payload.run_id,
+          JSON.stringify(logNotification),
+        );
       }
     } catch (error) {
       this.logger.error("Failed to capture tree state", error);

package/src/server/bin.ts

@@ -2,6 +2,7 @@
 import { Command } from "commander";
 import { z } from "zod";
 import { AgentServer } from "./agent-server.js";
+import { mcpServersSchema } from "./schemas.js";
 
 const envSchema = z.object({
   JWT_PUBLIC_KEY: z
@@ -45,6 +46,10 @@ program
   .requiredOption("--repositoryPath <path>", "Path to the repository")
   .requiredOption("--taskId <id>", "Task ID")
   .requiredOption("--runId <id>", "Task run ID")
+  .option(
+    "--mcpServers <json>",
+    "MCP servers config as JSON array (ACP McpServer[] format)",
+  )
   .action(async (options) => {
     const envResult = envSchema.safeParse(process.env);
 
@@ -60,6 +65,29 @@ program
 
     const mode = options.mode === "background" ? "background" : "interactive";
 
+    let mcpServers: z.infer<typeof mcpServersSchema> | undefined;
+    if (options.mcpServers) {
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(options.mcpServers);
+      } catch {
+        program.error("--mcpServers must be valid JSON");
+        return;
+      }
+
+      const result = mcpServersSchema.safeParse(parsed);
+      if (!result.success) {
+        const errors = result.error.issues
+          .map((issue) => `  - ${issue.path.join(".")}: ${issue.message}`)
+          .join("\n");
+        program.error(
+          `--mcpServers validation failed (only remote http/sse servers are supported):\n${errors}`,
+        );
+        return;
+      }
+      mcpServers = result.data;
+    }
+
     const server = new AgentServer({
       port: parseInt(options.port, 10),
       jwtPublicKey: env.JWT_PUBLIC_KEY,
@@ -70,6 +98,7 @@ program
       mode,
       taskId: options.taskId,
       runId: options.runId,
+      mcpServers,
     });
 
     process.on("SIGINT", async () => {

package/src/server/schemas.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, it } from "vitest";
+import { mcpServersSchema } from "./schemas.js";
+
+describe("mcpServersSchema", () => {
+  it("accepts a valid HTTP server", () => {
+    const result = mcpServersSchema.safeParse([
+      {
+        type: "http",
+        name: "my-server",
+        url: "https://mcp.example.com",
+        headers: [{ name: "Authorization", value: "Bearer tok" }],
+      },
+    ]);
+    expect(result.success).toBe(true);
+    expect(result.data).toEqual([
+      {
+        type: "http",
+        name: "my-server",
+        url: "https://mcp.example.com",
+        headers: [{ name: "Authorization", value: "Bearer tok" }],
+      },
+    ]);
+  });
+
+  it("accepts a valid SSE server", () => {
+    const result = mcpServersSchema.safeParse([
+      {
+        type: "sse",
+        name: "sse-server",
+        url: "https://sse.example.com/events",
+        headers: [],
+      },
+    ]);
+    expect(result.success).toBe(true);
+  });
+
+  it("defaults headers to empty array when omitted", () => {
+    const result = mcpServersSchema.safeParse([
+      { type: "http", name: "no-headers", url: "https://example.com" },
+    ]);
+    expect(result.success).toBe(true);
+    expect(result.data?.[0].headers).toEqual([]);
+  });
+
+  it("accepts multiple servers", () => {
+    const result = mcpServersSchema.safeParse([
+      { type: "http", name: "a", url: "https://a.com" },
+      { type: "sse", name: "b", url: "https://b.com" },
+    ]);
+    expect(result.success).toBe(true);
+    expect(result.data).toHaveLength(2);
+  });
+
+  it("accepts an empty array", () => {
+    const result = mcpServersSchema.safeParse([]);
+    expect(result.success).toBe(true);
+    expect(result.data).toEqual([]);
+  });
+
+  it("rejects stdio servers", () => {
+    const result = mcpServersSchema.safeParse([
+      {
+        type: "stdio",
+        name: "local",
+        command: "/usr/bin/mcp",
+        args: [],
+      },
+    ]);
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects servers with no type", () => {
+    const result = mcpServersSchema.safeParse([
+      { name: "missing-type", url: "https://example.com" },
+    ]);
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects servers with empty name", () => {
+    const result = mcpServersSchema.safeParse([
+      { type: "http", name: "", url: "https://example.com" },
+    ]);
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects servers with invalid url", () => {
+    const result = mcpServersSchema.safeParse([
+      { type: "http", name: "bad-url", url: "not-a-url" },
+    ]);
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects servers with missing url", () => {
+    const result = mcpServersSchema.safeParse([
+      { type: "http", name: "no-url" },
+    ]);
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects non-array input", () => {
+    expect(mcpServersSchema.safeParse("not-array").success).toBe(false);
+    expect(mcpServersSchema.safeParse({}).success).toBe(false);
+    expect(mcpServersSchema.safeParse(null).success).toBe(false);
+  });
+
+  it("rejects headers with missing fields", () => {
+    const result = mcpServersSchema.safeParse([
+      {
+        type: "http",
+        name: "bad-headers",
+        url: "https://example.com",
+        headers: [{ name: "X-Key" }],
+      },
+    ]);
+    expect(result.success).toBe(false);
+  });
+});

package/src/server/schemas.ts

@@ -1,5 +1,21 @@
 import { z } from "zod";
 
+const httpHeaderSchema = z.object({
+  name: z.string(),
+  value: z.string(),
+});
+
+const remoteMcpServerSchema = z.object({
+  type: z.enum(["http", "sse"]),
+  name: z.string().min(1, "MCP server name is required"),
+  url: z.string().url("MCP server url must be a valid URL"),
+  headers: z.array(httpHeaderSchema).default([]),
+});
+
+export const mcpServersSchema = z.array(remoteMcpServerSchema);
+
+export type RemoteMcpServer = z.infer<typeof remoteMcpServerSchema>;
+
 export const jsonRpcRequestSchema = z.object({
   jsonrpc: z.literal("2.0"),
   method: z.string(),

package/src/server/types.ts

@@ -1,4 +1,5 @@
 import type { AgentMode } from "../types.js";
+import type { RemoteMcpServer } from "./schemas.js";
 
 export interface AgentServerConfig {
   port: number;
@@ -11,4 +12,5 @@ export interface AgentServerConfig {
   taskId: string;
   runId: string;
   version?: string;
+  mcpServers?: RemoteMcpServer[];
 }