@posthog/agent 2.3.398 → 2.3.403

package/src/sagas/test-fixtures.ts

@@ -5,11 +5,10 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { promisify } from "node:util";
 import type { SagaLogger } from "@posthog/shared";
-import * as tar from "tar";
 import { vi } from "vitest";
 import { POSTHOG_NOTIFICATIONS } from "../acp-extensions";
 import type { PostHogAPIClient } from "../posthog-api";
-import type { StoredNotification, TaskRun, TreeSnapshot } from "../types";
+import type { GitCheckpointEvent, StoredNotification, TaskRun } from "../types";
 
 const execFileAsync = promisify(execFile);
 
@@ -128,7 +127,7 @@ export function createMockApiClient(
   return {
     uploadTaskArtifacts: vi
       .fn()
-      .mockResolvedValue([{ storage_path: "gs://bucket/trees/test.tar.gz" }]),
+      .mockResolvedValue([{ storage_path: "gs://bucket/handoff/test.pack" }]),
     downloadArtifact: vi.fn(),
     getTaskRun: vi.fn(),
     fetchTaskRunLogs: vi.fn(),
@@ -136,69 +135,6 @@ export function createMockApiClient(
   } as unknown as PostHogAPIClient;
 }
 
-export interface ArchiveFile {
-  path: string;
-  content: string;
-}
-
-export interface ArchiveSymlink {
-  path: string;
-  target: string;
-}
-
-export async function createArchiveBuffer(
-  files: Array<ArchiveFile>,
-  symlinks: Array<ArchiveSymlink> = [],
-): Promise<Buffer> {
-  const { symlink } = await import("node:fs/promises");
-  const tmpDir = join(
-    tmpdir(),
-    `archive-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-  );
-  await mkdir(tmpDir, { recursive: true });
-
-  const filesToArchive =
-    files.length > 0 ? files : [{ path: ".empty", content: "" }];
-
-  for (const file of filesToArchive) {
-    const fullPath = join(tmpDir, file.path);
-    await mkdir(join(fullPath, ".."), { recursive: true });
-    await writeFile(fullPath, file.content);
-  }
-
-  const symlinkPaths: string[] = [];
-  for (const link of symlinks) {
-    const fullPath = join(tmpDir, link.path);
-    await mkdir(join(fullPath, ".."), { recursive: true });
-    await symlink(link.target, fullPath);
-    symlinkPaths.push(link.path);
-  }
-
-  const archivePath = join(tmpDir, "archive.tar.gz");
-  await tar.create({ gzip: true, file: archivePath, cwd: tmpDir }, [
-    ...filesToArchive.map((f) => f.path),
-    ...symlinkPaths,
-  ]);
-
-  const content = await readFile(archivePath);
-  await rm(tmpDir, { recursive: true, force: true });
-
-  return Buffer.from(content.toString("base64"));
-}
-
-export function createSnapshot(
-  overrides: Partial<TreeSnapshot> = {},
-): TreeSnapshot {
-  return {
-    treeHash: "test-tree-hash",
-    baseCommit: null,
-    archiveUrl: "gs://bucket/trees/test.tar.gz",
-    changes: [],
-    timestamp: new Date().toISOString(),
-    ...overrides,
-  };
-}
-
 export function createTaskRun(overrides: Partial<TaskRun> = {}): TaskRun {
   return {
     id: "run-1",
@@ -290,17 +226,22 @@ export function createToolResult(
   });
 }
 
-export function createTreeSnapshotNotification(
-  treeHash: string,
-  archiveUrl?: string,
-  options: { interrupted?: boolean; device?: { type: "local" | "cloud" } } = {},
+export function createGitCheckpointNotification(
+  overrides: Partial<GitCheckpointEvent> = {},
 ): StoredNotification {
-  return createNotification(POSTHOG_NOTIFICATIONS.TREE_SNAPSHOT, {
-    treeHash,
-    baseCommit: "abc123",
-    archiveUrl,
-    changes: [{ path: "file.ts", status: "A" }],
+  return createNotification(POSTHOG_NOTIFICATIONS.GIT_CHECKPOINT, {
+    checkpointId: "checkpoint-1",
+    commit: "commit-1",
+    checkpointRef: "refs/posthog-code-checkpoint/checkpoint-1",
+    headRef: "refs/posthog-code-handoff/head/checkpoint-1",
+    head: "head-1",
+    branch: "main",
+    indexTree: "index-tree-1",
+    worktreeTree: "worktree-tree-1",
     timestamp: new Date().toISOString(),
-    ...options,
+    upstreamRemote: "origin",
+    upstreamMergeRef: "refs/heads/main",
+    remoteUrl: "git@github.com:posthog/posthog.git",
+    ...overrides,
   });
 }

package/src/server/agent-server.ts

@@ -35,7 +35,6 @@ import {
   resumeFromLog,
 } from "../resume";
 import { SessionLogWriter } from "../session-log-writer";
-import { TreeTracker } from "../tree-tracker";
 import type {
   AgentMode,
   DeviceInfo,
@@ -44,7 +43,6 @@ import type {
   LogLevel,
   TaskRun,
   TaskRunArtifact,
-  TreeSnapshotEvent,
 } from "../types";
 import { resourceLink } from "../utils/acp-content";
 import { AsyncMutex } from "../utils/async-mutex";
@@ -184,7 +182,6 @@ interface ActiveSession {
   acpSessionId: string;
   acpConnection: InProcessAcpConnection;
   clientConnection: ClientSideConnection;
-  treeTracker: TreeTracker | null;
   sseController: SseController | null;
   deviceInfo: DeviceInfo;
   logWriter: SessionLogWriter;
@@ -494,7 +491,6 @@ export class AgentServer {
       });
       this.logger.debug("Resume state loaded", {
         conversationTurns: this.resumeState.conversation.length,
-        hasSnapshot: !!this.resumeState.latestSnapshot,
         hasGitCheckpoint: !!this.resumeState.latestGitCheckpoint,
         gitCheckpointBranch:
           this.resumeState.latestGitCheckpoint?.branch ?? null,
@@ -823,16 +819,6 @@ export class AgentServer {
       userAgent: `posthog/cloud.hog.dev; version: ${this.config.version ?? packageJson.version}`,
     });
 
-    const treeTracker = this.config.repositoryPath
-      ? new TreeTracker({
-          repositoryPath: this.config.repositoryPath,
-          taskId: payload.task_id,
-          runId: payload.run_id,
-          apiClient: posthogAPI,
-          logger: new Logger({ debug: true, prefix: "[TreeTracker]" }),
-        })
-      : null;
-
     const logWriter = new SessionLogWriter({
       posthogAPI,
       logger: new Logger({ debug: true, prefix: "[SessionLogWriter]" }),
@@ -948,7 +934,6 @@ export class AgentServer {
       acpSessionId,
       acpConnection,
       clientConnection,
-      treeTracker,
       sseController,
       deviceInfo,
       logWriter,
@@ -1128,36 +1113,7 @@ export class AgentServer {
         this.resumeState.conversation,
       );
 
-      let snapshotApplied = false;
-      if (
-        this.resumeState.latestSnapshot?.archiveUrl &&
-        this.config.repositoryPath &&
-        this.posthogAPI
-      ) {
-        try {
-          const treeTracker = new TreeTracker({
-            repositoryPath: this.config.repositoryPath,
-            taskId: payload.task_id,
-            runId: payload.run_id,
-            apiClient: this.posthogAPI,
-            logger: this.logger.child("TreeTracker"),
-          });
-          await treeTracker.applyTreeSnapshot(this.resumeState.latestSnapshot);
-          treeTracker.setLastTreeHash(this.resumeState.latestSnapshot.treeHash);
-          snapshotApplied = true;
-          this.logger.info("Tree snapshot applied", {
-            treeHash: this.resumeState.latestSnapshot.treeHash,
-            changes: this.resumeState.latestSnapshot.changes?.length ?? 0,
-            hasArchiveUrl: !!this.resumeState.latestSnapshot.archiveUrl,
-          });
-        } catch (error) {
-          this.logger.warn("Failed to apply tree snapshot", {
-            error: error instanceof Error ? error.message : String(error),
-            treeHash: this.resumeState.latestSnapshot.treeHash,
-          });
-        }
-      }
-
+      let checkpointApplied = false;
       if (
         this.resumeState.latestGitCheckpoint &&
         this.config.repositoryPath &&
@@ -1174,6 +1130,7 @@ export class AgentServer {
           const metrics = await checkpointTracker.applyFromHandoff(
             this.resumeState.latestGitCheckpoint,
           );
+          checkpointApplied = true;
           this.logger.info("Git checkpoint applied", {
             branch: this.resumeState.latestGitCheckpoint.branch,
             head: this.resumeState.latestGitCheckpoint.head,
@@ -1191,9 +1148,9 @@ export class AgentServer {
 
       const pendingUserPrompt = await this.getPendingUserPrompt(taskRun);
 
-      const sandboxContext = snapshotApplied
-        ? `The workspace environment (all files, packages, and code changes) has been fully restored from where you left off.`
-        : `The workspace files from the previous session were not restored (the file snapshot may have expired), so you are starting with a fresh environment. Your conversation history is fully preserved below.`;
+      const sandboxContext = checkpointApplied
+        ? `The workspace environment (all files, packages, and code changes) has been fully restored from the latest checkpoint.`
+        : `The workspace from the previous session was not restored from a checkpoint, so you are starting with a fresh environment. Your conversation history is fully preserved below.`;
 
       let resumePromptBlocks: ContentBlock[];
       if (pendingUserPrompt?.length) {
@@ -1230,7 +1187,7 @@ export class AgentServer {
         conversationTurns: this.resumeState.conversation.length,
         promptLength: promptBlocksToText(resumePromptBlocks).length,
         hasPendingUserMessage: !!pendingUserPrompt?.length,
-        snapshotApplied,
+        checkpointApplied,
         hasGitCheckpoint: !!this.resumeState.latestGitCheckpoint,
         gitCheckpointBranch:
           this.resumeState.latestGitCheckpoint?.branch ?? null,
@@ -1933,7 +1890,8 @@ ${attributionInstructions}
         }
 
         // session/update notifications flow through the tapped stream (like local transport)
-        // Only handle tree state capture for file changes here
+        // Capture checkpoints for file-changing tools so cloud resumes restore
+        // from git checkpoints rather than tree snapshots.
         if (params.update?.sessionUpdate === "tool_call_update") {
           const meta = (params.update?._meta as Record<string, unknown>)
             ?.claudeCode as Record<string, unknown> | undefined;
@@ -1943,10 +1901,14 @@ ${attributionInstructions}
             | undefined;
 
           if (
-            (toolName === "Write" || toolName === "Edit") &&
+            (toolName === "Write" ||
+              toolName === "Edit" ||
+              toolName === "MultiEdit" ||
+              toolName === "Delete" ||
+              toolName === "Move") &&
             toolResponse?.filePath
           ) {
-            await this.captureTreeState();
+            await this.captureCheckpointState();
           }
 
           if (
@@ -2168,15 +2130,9 @@ ${attributionInstructions}
     this.logger.debug("Cleaning up session");
 
     try {
-      await this.captureHandoffCheckpoint();
-    } catch (error) {
-      this.logger.error("Failed to capture handoff checkpoint", error);
-    }
-
-    try {
-      await this.captureTreeState();
+      await this.captureCheckpointState(this.session.pendingHandoffGitState);
     } catch (error) {
-      this.logger.error("Failed to capture final tree state", error);
+      this.logger.error("Failed to capture final checkpoint state", error);
     }
 
     try {
@@ -2212,50 +2168,15 @@ ${attributionInstructions}
     this.session = null;
   }
 
-  private async captureTreeState(): Promise<void> {
-    if (!this.session?.treeTracker) return;
-
-    try {
-      const snapshot = await this.session.treeTracker.captureTree({});
-      if (snapshot) {
-        const snapshotWithDevice: TreeSnapshotEvent = {
-          ...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,
-        });
-
-        // Persist full snapshot (including archiveUrl) so resume can restore files.
-        // archiveUrl is a pre-signed S3 URL that expires — if the user resumes
-        // after expiry, ApplySnapshotSaga fails gracefully and the agent continues
-        // with conversation context but a fresh sandbox (snapshotApplied=false).
-        this.session.logWriter.appendRawLine(
-          this.session.payload.run_id,
-          JSON.stringify(notification),
-        );
-      }
-    } catch (error) {
-      this.logger.error("Failed to capture tree state", error);
-    }
-  }
-
-  private async captureHandoffCheckpoint(): Promise<void> {
-    if (!this.session?.treeTracker || !this.session.pendingHandoffGitState) {
+  private async captureCheckpointState(
+    localGitState?: HandoffLocalGitState,
+  ): Promise<void> {
+    if (!this.session || !this.config.repositoryPath) {
       return;
     }
     if (!this.posthogAPI) {
       this.logger.warn(
-        "Skipping handoff checkpoint capture: PostHog API client is not configured",
+        "Skipping checkpoint capture: PostHog API client is not configured",
       );
       return;
     }
@@ -2268,9 +2189,7 @@ ${attributionInstructions}
       logger: this.logger.child("HandoffCheckpoint"),
     });
 
-    const checkpoint = await tracker.captureForHandoff(
-      this.session.pendingHandoffGitState,
-    );
+    const checkpoint = await tracker.captureForHandoff(localGitState);
     if (!checkpoint) return;
 
     const checkpointWithDevice: GitCheckpointEvent = {

package/src/test/fixtures/api.ts

@@ -6,7 +6,7 @@ import { join } from "node:path";
 import { promisify } from "node:util";
 import { vi } from "vitest";
 import type { PostHogAPIClient } from "../../posthog-api";
-import type { TaskRun, TreeSnapshot } from "../../types";
+import type { TaskRun } from "../../types";
 
 const execFileAsync = promisify(execFile);
 
@@ -70,7 +70,7 @@ export function createMockApiClient(
   return {
     uploadTaskArtifacts: vi
       .fn()
-      .mockResolvedValue([{ storage_path: "gs://bucket/trees/test.tar.gz" }]),
+      .mockResolvedValue([{ storage_path: "gs://bucket/handoff/test.pack" }]),
     downloadArtifact: vi.fn(),
     getTaskRun: vi.fn(),
     fetchTaskRunLogs: vi.fn(),
@@ -97,16 +97,3 @@ export function createTaskRun(overrides: Partial<TaskRun> = {}): TaskRun {
     ...overrides,
   };
 }
-
-export function createSnapshot(
-  overrides: Partial<TreeSnapshot> = {},
-): TreeSnapshot {
-  return {
-    treeHash: "test-tree-hash",
-    baseCommit: null,
-    archiveUrl: "gs://bucket/trees/test.tar.gz",
-    changes: [],
-    timestamp: new Date().toISOString(),
-    ...overrides,
-  };
-}

package/src/types.ts

@@ -61,7 +61,6 @@ export type ArtifactType =
   | "reference"
   | "output"
   | "artifact"
-  | "tree_snapshot"
   | "user_attachment";
 
 export interface TaskRunArtifact {
@@ -187,21 +186,6 @@ export interface FileChange {
   status: FileStatus;
 }
 
-// Tree snapshot - what TreeTracker captures
-export interface TreeSnapshot {
-  treeHash: string;
-  baseCommit: string | null;
-  archiveUrl?: string;
-  changes: FileChange[];
-  timestamp: string;
-  interrupted?: boolean;
-}
-
-// Tree snapshot event - includes device info when sent as notification
-export interface TreeSnapshotEvent extends TreeSnapshot {
-  device?: DeviceInfo;
-}
-
 export type HandoffLocalGitState = GitHandoffLocalGitState;
 
 export interface GitCheckpoint extends GitHandoffCheckpoint {

package/dist/tree-tracker.d.ts

@@ -1,68 +0,0 @@
-import { PostHogAPIClient } from './posthog-api.js';
-import { TreeSnapshot } from './types.js';
-import { L as Logger } from './logger-RC7sPv0S.js';
-import '@posthog/git/handoff';
-
-/**
- * TreeTracker - Git tree-based state capture for cloud/local sync
- *
- * Captures the entire working state as a git tree hash + archive:
- * - Atomic state snapshots (no partial syncs)
- * - Efficient delta detection using git's diffing
- * - Simpler resume logic (restore tree, continue)
- *
- * Uses Saga pattern for atomic operations with automatic rollback on failure.
- * Uses a temporary git index to avoid modifying the user's staging area.
- */
-
-interface TreeTrackerConfig {
-    repositoryPath: string;
-    taskId: string;
-    runId: string;
-    apiClient?: PostHogAPIClient;
-    logger?: Logger;
-}
-declare class TreeTracker {
-    private repositoryPath;
-    private taskId;
-    private runId;
-    private apiClient?;
-    private logger;
-    private lastTreeHash;
-    constructor(config: TreeTrackerConfig);
-    /**
-     * Capture current working tree state as a snapshot.
-     * Uses a temporary index to avoid modifying user's staging area.
-     * Uses Saga pattern for atomic operation with automatic cleanup on failure.
-     */
-    captureTree(options?: {
-        interrupted?: boolean;
-    }): Promise<TreeSnapshot | null>;
-    /**
-     * Download and apply a tree snapshot.
-     * Uses Saga pattern for atomic operation with rollback on failure.
-     */
-    applyTreeSnapshot(snapshot: TreeSnapshot): Promise<void>;
-    /**
-     * Get the last captured tree hash.
-     */
-    getLastTreeHash(): string | null;
-    /**
-     * Set the last tree hash (used when resuming).
-     */
-    setLastTreeHash(hash: string | null): void;
-}
-/**
- * Check if a commit is available on any remote branch.
- * Used to validate that cloud can fetch the base commit during handoff.
- */
-declare function isCommitOnRemote(commit: string, cwd: string): Promise<boolean>;
-/**
- * Validate that a snapshot can be handed off to cloud execution.
- * Cloud needs to be able to fetch the baseCommit from a remote.
- *
- * @throws Error if the snapshot cannot be restored on cloud
- */
-declare function validateForCloudHandoff(snapshot: TreeSnapshot, repositoryPath: string): Promise<void>;
-
-export { TreeSnapshot, TreeTracker, type TreeTrackerConfig, isCommitOnRemote, validateForCloudHandoff };