@posthog/agent 2.3.398 → 2.3.403

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

@@ -1,150 +0,0 @@
-import { existsSync } from "node:fs";
-import { readFile, rm } from "node:fs/promises";
-import { join } from "node:path";
-import { CaptureTreeSaga as GitCaptureTreeSaga } from "@posthog/git/sagas/tree";
-import { Saga } from "@posthog/shared";
-import type { PostHogAPIClient } from "../posthog-api";
-import type { TreeSnapshot } from "../types";
-
-export interface CaptureTreeInput {
-  repositoryPath: string;
-  taskId: string;
-  runId: string;
-  apiClient?: PostHogAPIClient;
-  lastTreeHash: string | null;
-  interrupted?: boolean;
-}
-
-export interface CaptureTreeOutput {
-  snapshot: TreeSnapshot | null;
-  newTreeHash: string | null;
-}
-
-export class CaptureTreeSaga extends Saga<CaptureTreeInput, CaptureTreeOutput> {
-  readonly sagaName = "CaptureTreeSaga";
-
-  protected async execute(input: CaptureTreeInput): Promise<CaptureTreeOutput> {
-    const {
-      repositoryPath,
-      lastTreeHash,
-      interrupted,
-      apiClient,
-      taskId,
-      runId,
-    } = input;
-    const tmpDir = join(repositoryPath, ".posthog", "tmp");
-
-    if (existsSync(join(repositoryPath, ".gitmodules"))) {
-      this.log.warn(
-        "Repository has submodules - snapshot may not capture submodule state",
-      );
-    }
-
-    const shouldArchive = !!apiClient;
-    const archivePath = shouldArchive
-      ? join(tmpDir, `tree-${Date.now()}.tar.gz`)
-      : undefined;
-
-    const gitCaptureSaga = new GitCaptureTreeSaga(this.log);
-    const captureResult = await gitCaptureSaga.run({
-      baseDir: repositoryPath,
-      lastTreeHash,
-      archivePath,
-    });
-
-    if (!captureResult.success) {
-      throw new Error(`Failed to capture tree: ${captureResult.error}`);
-    }
-
-    const {
-      snapshot: gitSnapshot,
-      archivePath: createdArchivePath,
-      changed,
-    } = captureResult.data;
-
-    if (!changed || !gitSnapshot) {
-      this.log.debug("No changes since last capture", { lastTreeHash });
-      return { snapshot: null, newTreeHash: lastTreeHash };
-    }
-
-    let archiveUrl: string | undefined;
-    if (apiClient && createdArchivePath) {
-      try {
-        archiveUrl = await this.uploadArchive(
-          createdArchivePath,
-          gitSnapshot.treeHash,
-          apiClient,
-          taskId,
-          runId,
-        );
-      } finally {
-        await rm(createdArchivePath, { force: true }).catch(() => {});
-      }
-    }
-
-    const snapshot: TreeSnapshot = {
-      treeHash: gitSnapshot.treeHash,
-      baseCommit: gitSnapshot.baseCommit,
-      changes: gitSnapshot.changes,
-      timestamp: gitSnapshot.timestamp,
-      interrupted,
-      archiveUrl,
-    };
-
-    this.log.info("Tree captured", {
-      treeHash: snapshot.treeHash,
-      changes: snapshot.changes.length,
-      interrupted,
-      archiveUrl,
-    });
-
-    return { snapshot, newTreeHash: snapshot.treeHash };
-  }
-
-  private async uploadArchive(
-    archivePath: string,
-    treeHash: string,
-    apiClient: PostHogAPIClient,
-    taskId: string,
-    runId: string,
-  ): Promise<string | undefined> {
-    const archiveUrl = await this.step({
-      name: "upload_archive",
-      execute: async () => {
-        const archiveContent = await readFile(archivePath);
-        const base64Content = archiveContent.toString("base64");
-        const snapshotBytes = archiveContent.byteLength;
-        const snapshotWireBytes = Buffer.byteLength(base64Content, "utf-8");
-
-        const artifacts = await apiClient.uploadTaskArtifacts(taskId, runId, [
-          {
-            name: `trees/${treeHash}.tar.gz`,
-            type: "tree_snapshot",
-            content: base64Content,
-            content_type: "application/gzip",
-          },
-        ]);
-
-        const uploadedArtifact = artifacts[0];
-        if (uploadedArtifact?.storage_path) {
-          this.log.info("Tree archive uploaded", {
-            storagePath: uploadedArtifact.storage_path,
-            treeHash,
-            snapshotBytes,
-            snapshotWireBytes,
-            totalBytes: snapshotBytes,
-            totalWireBytes: snapshotWireBytes,
-          });
-          return uploadedArtifact.storage_path;
-        }
-
-        return undefined;
-      },
-      rollback: async () => {
-        await rm(archivePath, { force: true }).catch(() => {});
-      },
-    });
-
-    return archiveUrl;
-  }
-}

package/src/tree-tracker.ts

@@ -1,173 +0,0 @@
-/**
- * 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.
- */
-
-import { isCommitOnRemote as gitIsCommitOnRemote } from "@posthog/git/queries";
-import type { PostHogAPIClient } from "./posthog-api";
-import { ApplySnapshotSaga } from "./sagas/apply-snapshot-saga";
-import { CaptureTreeSaga } from "./sagas/capture-tree-saga";
-import type { TreeSnapshot } from "./types";
-import { Logger } from "./utils/logger";
-
-export type { TreeSnapshot };
-
-export interface TreeTrackerConfig {
-  repositoryPath: string;
-  taskId: string;
-  runId: string;
-  apiClient?: PostHogAPIClient;
-  logger?: Logger;
-}
-
-export class TreeTracker {
-  private repositoryPath: string;
-  private taskId: string;
-  private runId: string;
-  private apiClient?: PostHogAPIClient;
-  private logger: Logger;
-  private lastTreeHash: string | null = null;
-
-  constructor(config: TreeTrackerConfig) {
-    this.repositoryPath = config.repositoryPath;
-    this.taskId = config.taskId;
-    this.runId = config.runId;
-    this.apiClient = config.apiClient;
-    this.logger =
-      config.logger || new Logger({ debug: false, prefix: "[TreeTracker]" });
-  }
-
-  /**
-   * 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.
-   */
-  async captureTree(options?: {
-    interrupted?: boolean;
-  }): Promise<TreeSnapshot | null> {
-    const saga = new CaptureTreeSaga(this.logger);
-
-    const result = await saga.run({
-      repositoryPath: this.repositoryPath,
-      taskId: this.taskId,
-      runId: this.runId,
-      apiClient: this.apiClient,
-      lastTreeHash: this.lastTreeHash,
-      interrupted: options?.interrupted,
-    });
-
-    if (!result.success) {
-      this.logger.error("Failed to capture tree", {
-        error: result.error,
-        failedStep: result.failedStep,
-      });
-      throw new Error(
-        `Failed to capture tree at step '${result.failedStep}': ${result.error}`,
-      );
-    }
-
-    // Only update lastTreeHash on success
-    if (result.data.newTreeHash !== null) {
-      this.lastTreeHash = result.data.newTreeHash;
-    }
-
-    return result.data.snapshot;
-  }
-
-  /**
-   * Download and apply a tree snapshot.
-   * Uses Saga pattern for atomic operation with rollback on failure.
-   */
-  async applyTreeSnapshot(snapshot: TreeSnapshot): Promise<void> {
-    if (!this.apiClient) {
-      throw new Error("Cannot apply snapshot: API client not configured");
-    }
-
-    if (!snapshot.archiveUrl) {
-      this.logger.warn("Cannot apply snapshot: no archive URL", {
-        treeHash: snapshot.treeHash,
-        changes: snapshot.changes.length,
-      });
-      throw new Error("Cannot apply snapshot: no archive URL");
-    }
-
-    const saga = new ApplySnapshotSaga(this.logger);
-
-    const result = await saga.run({
-      snapshot,
-      repositoryPath: this.repositoryPath,
-      apiClient: this.apiClient,
-      taskId: this.taskId,
-      runId: this.runId,
-    });
-
-    if (!result.success) {
-      this.logger.error("Failed to apply tree snapshot", {
-        error: result.error,
-        failedStep: result.failedStep,
-        treeHash: snapshot.treeHash,
-      });
-      throw new Error(
-        `Failed to apply snapshot at step '${result.failedStep}': ${result.error}`,
-      );
-    }
-
-    // Only update lastTreeHash on success
-    this.lastTreeHash = result.data.treeHash;
-  }
-
-  /**
-   * Get the last captured tree hash.
-   */
-  getLastTreeHash(): string | null {
-    return this.lastTreeHash;
-  }
-
-  /**
-   * Set the last tree hash (used when resuming).
-   */
-  setLastTreeHash(hash: string | null): void {
-    this.lastTreeHash = hash;
-  }
-}
-
-/**
- * Check if a commit is available on any remote branch.
- * Used to validate that cloud can fetch the base commit during handoff.
- */
-export async function isCommitOnRemote(
-  commit: string,
-  cwd: string,
-): Promise<boolean> {
-  return gitIsCommitOnRemote(cwd, commit);
-}
-
-/**
- * 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
- */
-export async function validateForCloudHandoff(
-  snapshot: TreeSnapshot,
-  repositoryPath: string,
-): Promise<void> {
-  if (!snapshot.baseCommit) {
-    throw new Error("Cannot hand off to cloud: no base commit");
-  }
-
-  const onRemote = await isCommitOnRemote(snapshot.baseCommit, repositoryPath);
-  if (!onRemote) {
-    throw new Error(
-      `Cannot hand off to cloud: commit ${snapshot.baseCommit.slice(0, 7)} is not pushed. ` +
-        `Run 'git push' to push your branch first.`,
-    );
-  }
-}