@posthog/agent 2.1.150 → 2.1.156

package/dist/server/bin.cjs

@@ -904,7 +904,7 @@ var import_hono = require("hono");
 // package.json
 var package_default = {
   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: {
@@ -1810,8 +1810,14 @@ function toolInfoFromToolUse(toolUse, options) {
       };
     case "Edit": {
       const path9 = input?.file_path ? String(input.file_path) : void 0;
-      const oldText = input?.old_string ? String(input.old_string) : null;
-      const newText = input?.new_string ? String(input.new_string) : "";
+      let oldText = input?.old_string ? String(input.old_string) : null;
+      let newText = input?.new_string ? String(input.new_string) : "";
+      if (path9 && options?.cachedFileContent && path9 in options.cachedFileContent) {
+        const oldContent = options.cachedFileContent[path9];
+        const newContent = input?.replace_all ? oldContent.replaceAll(oldText ?? "", newText) : oldContent.replace(oldText ?? "", newText);
+        oldText = oldContent;
+        newText = newContent;
+      }
       return {
         title: path9 ? `Edit \`${path9}\`` : "Edit",
         kind: "edit",
@@ -1831,7 +1837,8 @@ function toolInfoFromToolUse(toolUse, options) {
       const filePath = input?.file_path ? String(input.file_path) : void 0;
       const contentStr = input?.content ? String(input.content) : void 0;
       if (filePath) {
-        contentResult = toolContent().diff(filePath, null, contentStr ?? "").build();
+        const oldContent = options?.cachedFileContent && filePath in options.cachedFileContent ? options.cachedFileContent[filePath] : null;
+        contentResult = toolContent().diff(filePath, oldContent, contentStr ?? "").build();
       } else if (contentStr) {
         contentResult = toolContent().text(contentStr).build();
       }
@@ -2325,7 +2332,8 @@ function handleToolUseChunk(chunk, ctx) {
   }
   const toolInfo = toolInfoFromToolUse(chunk, {
     supportsTerminalOutput: ctx.supportsTerminalOutput,
-    toolUseId: chunk.id
+    toolUseId: chunk.id,
+    cachedFileContent: ctx.fileContentCache
   });
   const meta = {
     ...toolMeta(chunk.name, void 0, ctx.parentToolCallId)
@@ -2351,6 +2359,47 @@ function handleToolUseChunk(chunk, ctx) {
     ...toolInfo
   };
 }
+function extractTextFromContent(content) {
+  if (Array.isArray(content)) {
+    const parts = [];
+    for (const item of content) {
+      if (typeof item === "object" && item !== null && "text" in item && typeof item.text === "string") {
+        parts.push(item.text);
+      }
+    }
+    return parts.length > 0 ? parts.join("") : null;
+  }
+  if (typeof content === "string") {
+    return content;
+  }
+  return null;
+}
+function stripCatLineNumbers(text2) {
+  return text2.replace(/^ *\d+[\t→]/gm, "");
+}
+function updateFileContentCache(toolUse, chunk, ctx) {
+  const input = toolUse.input;
+  const filePath = input?.file_path ? String(input.file_path) : void 0;
+  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, ctx) {
   const toolUse = ctx.toolUseCache[chunk.tool_use_id];
   if (!toolUse) {
@@ -2362,12 +2411,16 @@ function handleToolResultChunk(chunk, ctx) {
   if (toolUse.name === "TodoWrite") {
     return [];
   }
+  if (!chunk.is_error) {
+    updateFileContentCache(toolUse, chunk, ctx);
+  }
   const { _meta: resultMeta, ...toolUpdate } = toolUpdateFromToolResult(
     chunk,
     toolUse,
     {
       supportsTerminalOutput: ctx.supportsTerminalOutput,
-      toolUseId: chunk.tool_use_id
+      toolUseId: chunk.tool_use_id,
+      cachedFileContent: ctx.fileContentCache
     }
   );
   const updates = [];
@@ -10894,6 +10947,17 @@ function validateJwt(token, publicKey) {
 
 // src/server/schemas.ts
 var import_zod3 = require("zod");
+var httpHeaderSchema = import_zod3.z.object({
+  name: import_zod3.z.string(),
+  value: import_zod3.z.string()
+});
+var remoteMcpServerSchema = import_zod3.z.object({
+  type: import_zod3.z.enum(["http", "sse"]),
+  name: import_zod3.z.string().min(1, "MCP server name is required"),
+  url: import_zod3.z.string().url("MCP server url must be a valid URL"),
+  headers: import_zod3.z.array(httpHeaderSchema).default([])
+});
+var mcpServersSchema = import_zod3.z.array(remoteMcpServerSchema);
 var jsonRpcRequestSchema = import_zod3.z.object({
   jsonrpc: import_zod3.z.literal("2.0"),
   method: import_zod3.z.string(),
@@ -11018,6 +11082,24 @@ var AgentServer = class {
   posthogAPI;
   questionRelayedToSlack = false;
   detectedPrUrl = null;
+  emitConsoleLog = (level, _scope, message, data) => {
+    if (!this.session) return;
+    const formatted = data !== void 0 ? `${message} ${JSON.stringify(data)}` : message;
+    const notification = {
+      jsonrpc: "2.0",
+      method: POSTHOG_NOTIFICATIONS.CONSOLE,
+      params: { level, message: formatted }
+    };
+    this.broadcastEvent({
+      type: "notification",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      notification
+    });
+    this.session.logWriter.appendRawLine(
+      this.session.payload.run_id,
+      JSON.stringify(notification)
+    );
+  };
   constructor(config) {
     this.config = config;
     this.logger = new Logger({ debug: true, prefix: "[AgentServer]" });
@@ -11347,7 +11429,7 @@ You MUST NOT create a new branch, close the existing PR, or create a new PR.`
     }
     const sessionResponse = await clientConnection.newSession({
       cwd: this.config.repositoryPath,
-      mcpServers: [],
+      mcpServers: this.config.mcpServers ?? [],
       _meta: {
         sessionId: payload.run_id,
         taskRunId: payload.run_id,
@@ -11369,6 +11451,14 @@ You MUST NOT create a new branch, close the existing PR, or create a new PR.`
       deviceInfo,
       logWriter
     };
+    this.logger = new Logger({
+      debug: true,
+      prefix: "[AgentServer]",
+      onLog: (level, scope, message, data) => {
+        const _formatted = data !== void 0 ? `${message} ${JSON.stringify(data)}` : message;
+        this.emitConsoleLog(level, scope, message, data);
+      }
+    });
     this.logger.info("Session initialized successfully");
     this.posthogAPI.updateTaskRun(payload.task_id, payload.run_id, {
       status: "in_progress"
@@ -11751,15 +11841,25 @@ Important:
           ...snapshot,
           device: this.session.deviceInfo
         };
+        const notification = {
+          jsonrpc: "2.0",
+          method: POSTHOG_NOTIFICATIONS.TREE_SNAPSHOT,
+          params: snapshotWithDevice
+        };
         this.broadcastEvent({
           type: "notification",
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          notification: {
-            jsonrpc: "2.0",
-            method: POSTHOG_NOTIFICATIONS.TREE_SNAPSHOT,
-            params: snapshotWithDevice
-          }
+          notification
         });
+        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);
@@ -11795,7 +11895,10 @@ program.name("agent-server").description("PostHog cloud agent server - runs in s
   "--mode <mode>",
   "Execution mode: interactive or background",
   "interactive"
-).requiredOption("--repositoryPath <path>", "Path to the repository").requiredOption("--taskId <id>", "Task ID").requiredOption("--runId <id>", "Task run ID").action(async (options) => {
+).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);
   if (!envResult.success) {
     const errors = envResult.error.issues.map((issue) => `  - ${issue.message}`).join("\n");
@@ -11805,6 +11908,26 @@ ${errors}`);
   }
   const env = envResult.data;
   const mode = options.mode === "background" ? "background" : "interactive";
+  let mcpServers;
+  if (options.mcpServers) {
+    let parsed;
+    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):
+${errors}`
+      );
+      return;
+    }
+    mcpServers = result.data;
+  }
   const server = new AgentServer({
     port: parseInt(options.port, 10),
     jwtPublicKey: env.JWT_PUBLIC_KEY,
@@ -11814,7 +11937,8 @@ ${errors}`);
     projectId: env.POSTHOG_PROJECT_ID,
     mode,
     taskId: options.taskId,
-    runId: options.runId
+    runId: options.runId,
+    mcpServers
   });
   process.on("SIGINT", async () => {
     await server.stop();