@posthog/agent 2.1.148 → 2.1.152

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/agent",
-  "version": "2.1.148",
+  "version": "2.1.152",
   "repository": "https://github.com/PostHog/twig",
   "description": "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   "exports": {

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/adapters/claude/session/options.ts

@@ -140,6 +140,7 @@ function buildSpawnWrapper(
   sessionId: string,
   onProcessSpawned: (info: ProcessSpawnedInfo) => void,
   onProcessExited?: (pid: number) => void,
+  logger?: Logger,
 ): (options: SpawnOptions) => SpawnedProcess {
   return (spawnOpts: SpawnOptions): SpawnedProcess => {
     const child = spawn(spawnOpts.command, spawnOpts.args, {
@@ -156,6 +157,13 @@ function buildSpawnWrapper(
       });
     }
 
+    child.stderr?.on("data", (data: Buffer) => {
+      const msg = data.toString().trim();
+      if (msg && logger) {
+        logger.debug(`[claude-code:${child.pid}] stderr: ${msg}`);
+      }
+    });
+
     if (onProcessExited) {
       child.on("exit", () => {
         if (child.pid) {
@@ -256,6 +264,7 @@ export function buildSessionOptions(params: BuildOptionsParams): Options {
         params.sessionId,
         params.onProcessSpawned,
         params.onProcessExited,
+        params.logger,
       ),
     }),
   };

package/src/adapters/codex/spawn.ts

@@ -101,7 +101,7 @@ export function spawnCodexProcess(options: CodexProcessOptions): CodexProcess {
   });
 
   child.stderr?.on("data", (data: Buffer) => {
-    logger.debug("codex-acp stderr:", data.toString());
+    logger.warn("codex-acp stderr:", data.toString());
   });
 
   child.on("error", (err) => {

package/src/agent.ts

@@ -36,6 +36,12 @@ export class Agent {
         logger: this.logger.child("SessionLogWriter"),
         localCachePath: config.localCachePath,
       });
+
+      if (config.localCachePath) {
+        SessionLogWriter.cleanupOldSessions(config.localCachePath).catch(
+          () => {},
+        );
+      }
     }
   }
 
@@ -69,7 +75,9 @@ export class Agent {
     options: TaskExecutionOptions = {},
   ): Promise<InProcessAcpConnection> {
     const gatewayConfig = this._configureLlmGateway(options.adapter);
-    this.logger.info("Configured LLM gateway", options);
+    this.logger.info("Configured LLM gateway", {
+      adapter: options.adapter,
+    });
     this.taskRunId = taskRunId;
 
     let allowedModelIds: Set<string> | undefined;

package/src/sagas/apply-snapshot-saga.ts

@@ -21,6 +21,8 @@ export class ApplySnapshotSaga extends Saga<
   ApplySnapshotInput,
   ApplySnapshotOutput
 > {
+  readonly sagaName = "ApplySnapshotSaga";
+
   private archivePath: string | null = null;
 
   protected async execute(

package/src/sagas/capture-tree-saga.ts

@@ -21,6 +21,8 @@ export interface CaptureTreeOutput {
 }
 
 export class CaptureTreeSaga extends Saga<CaptureTreeInput, CaptureTreeOutput> {
+  readonly sagaName = "CaptureTreeSaga";
+
   protected async execute(input: CaptureTreeInput): Promise<CaptureTreeOutput> {
     const {
       repositoryPath,

package/src/sagas/resume-saga.ts

@@ -41,6 +41,8 @@ export interface ResumeOutput {
 }
 
 export class ResumeSaga extends Saga<ResumeInput, ResumeOutput> {
+  readonly sagaName = "ResumeSaga";
+
   protected async execute(input: ResumeInput): Promise<ResumeOutput> {
     const { taskId, runId, repositoryPath, apiClient } = input;
     const logger =

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]" });
@@ -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/session-log-writer.ts

@@ -1,4 +1,5 @@
 import fs from "node:fs";
+import fsp from "node:fs/promises";
 import path from "node:path";
 import type { SessionContext } from "./otel-log-writer.js";
 import type { PostHogAPIClient } from "./posthog-api.js";
@@ -30,6 +31,7 @@ export class SessionLogWriter {
   private static readonly FLUSH_MAX_INTERVAL_MS = 5000;
   private static readonly MAX_FLUSH_RETRIES = 10;
   private static readonly MAX_RETRY_DELAY_MS = 30_000;
+  private static readonly SESSIONS_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
 
   private posthogAPI?: PostHogAPIClient;
   private pendingEntries: Map<string, StoredNotification[]> = new Map();
@@ -196,10 +198,16 @@ export class SessionLogWriter {
         );
         this.retryCounts.set(sessionId, 0);
       } else {
-        this.logger.error(
-          `Failed to persist session logs (attempt ${retryCount}/${SessionLogWriter.MAX_FLUSH_RETRIES}):`,
-          error,
-        );
+        if (retryCount === 1) {
+          this.logger.warn(
+            `Failed to persist session logs, will retry (up to ${SessionLogWriter.MAX_FLUSH_RETRIES} attempts)`,
+            {
+              taskId: session.context.taskId,
+              runId: session.context.runId,
+              error: error instanceof Error ? error.message : String(error),
+            },
+          );
+        }
         const currentPending = this.pendingEntries.get(sessionId) ?? [];
         this.pendingEntries.set(sessionId, [...pending, ...currentPending]);
         this.scheduleFlush(sessionId);
@@ -344,4 +352,31 @@ export class SessionLogWriter {
       });
     }
   }
+
+  static async cleanupOldSessions(localCachePath: string): Promise<number> {
+    const sessionsDir = path.join(localCachePath, "sessions");
+    let deleted = 0;
+    try {
+      const entries = await fsp.readdir(sessionsDir);
+      const now = Date.now();
+      for (const entry of entries) {
+        const entryPath = path.join(sessionsDir, entry);
+        try {
+          const stats = await fsp.stat(entryPath);
+          if (
+            stats.isDirectory() &&
+            now - stats.birthtimeMs > SessionLogWriter.SESSIONS_MAX_AGE_MS
+          ) {
+            await fsp.rm(entryPath, { recursive: true, force: true });
+            deleted++;
+          }
+        } catch {
+          // Skip entries we can't stat
+        }
+      }
+    } catch {
+      // Sessions dir may not exist yet
+    }
+    return deleted;
+  }
 }