@posthog/agent 2.3.398 → 2.3.401

package/dist/tree-tracker.js

@@ -5679,7 +5679,7 @@ async function isCommitOnRemote(baseDir, commit, options) {
 }
 
 // src/sagas/apply-snapshot-saga.ts
-import { mkdir as mkdir3, rm as rm2, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir3, readdir, rm as rm2, rmdir, writeFile as writeFile3 } from "fs/promises";
 import { join as join3 } from "path";
 
 // ../git/dist/sagas/tree.js
@@ -6094,68 +6094,83 @@ var ApplySnapshotSaga = class extends Saga {
       throw new Error("Cannot apply snapshot: no archive URL");
     }
     const archiveUrl = snapshot.archiveUrl;
-    await this.step({
-      name: "create_tmp_dir",
-      execute: () => mkdir3(tmpDir, { recursive: true }),
-      rollback: async () => {
-      }
-    });
-    const archivePath = join3(tmpDir, `${snapshot.treeHash}.tar.gz`);
-    this.archivePath = archivePath;
-    await this.step({
-      name: "download_archive",
-      execute: async () => {
-        const arrayBuffer = await apiClient.downloadArtifact(
-          taskId,
-          runId,
-          archiveUrl
-        );
-        if (!arrayBuffer) {
-          throw new Error("Failed to download archive");
+    try {
+      await this.step({
+        name: "create_tmp_dir",
+        execute: () => mkdir3(tmpDir, { recursive: true }),
+        rollback: async () => {
         }
-        const base64Content = Buffer.from(arrayBuffer).toString("utf-8");
-        const binaryContent = Buffer.from(base64Content, "base64");
-        await writeFile3(archivePath, binaryContent);
-        this.log.info("Tree archive downloaded", {
-          treeHash: snapshot.treeHash,
-          snapshotBytes: binaryContent.byteLength,
-          snapshotWireBytes: arrayBuffer.byteLength,
-          totalBytes: binaryContent.byteLength,
-          totalWireBytes: arrayBuffer.byteLength
-        });
-      },
-      rollback: async () => {
-        if (this.archivePath) {
-          await rm2(this.archivePath, { force: true }).catch(() => {
+      });
+      const archivePath = join3(tmpDir, `${snapshot.treeHash}.tar.gz`);
+      this.archivePath = archivePath;
+      await this.step({
+        name: "download_archive",
+        execute: async () => {
+          const arrayBuffer = await apiClient.downloadArtifact(
+            taskId,
+            runId,
+            archiveUrl
+          );
+          if (!arrayBuffer) {
+            throw new Error("Failed to download archive");
+          }
+          const base64Content = Buffer.from(arrayBuffer).toString("utf-8");
+          const binaryContent = Buffer.from(base64Content, "base64");
+          await writeFile3(archivePath, binaryContent);
+          this.log.info("Tree archive downloaded", {
+            treeHash: snapshot.treeHash,
+            snapshotBytes: binaryContent.byteLength,
+            snapshotWireBytes: arrayBuffer.byteLength,
+            totalBytes: binaryContent.byteLength,
+            totalWireBytes: arrayBuffer.byteLength
           });
+        },
+        rollback: async () => {
+          if (this.archivePath) {
+            await rm2(this.archivePath, { force: true }).catch(() => {
+            });
+          }
         }
+      });
+      const gitApplySaga = new ApplyTreeSaga(this.log);
+      const applyResult = await gitApplySaga.run({
+        baseDir: repositoryPath,
+        treeHash: snapshot.treeHash,
+        baseCommit: snapshot.baseCommit,
+        changes: snapshot.changes,
+        archivePath: this.archivePath
+      });
+      if (!applyResult.success) {
+        throw new Error(`Failed to apply tree: ${applyResult.error}`);
       }
-    });
-    const gitApplySaga = new ApplyTreeSaga(this.log);
-    const applyResult = await gitApplySaga.run({
-      baseDir: repositoryPath,
-      treeHash: snapshot.treeHash,
-      baseCommit: snapshot.baseCommit,
-      changes: snapshot.changes,
-      archivePath: this.archivePath
-    });
-    if (!applyResult.success) {
-      throw new Error(`Failed to apply tree: ${applyResult.error}`);
+      this.log.info("Tree snapshot applied", {
+        treeHash: snapshot.treeHash,
+        totalChanges: snapshot.changes.length,
+        deletedFiles: snapshot.changes.filter((c) => c.status === "D").length
+      });
+      return { treeHash: snapshot.treeHash };
+    } finally {
+      if (this.archivePath) {
+        await rm2(this.archivePath, { force: true }).catch(() => {
+        });
+      }
+      await this.removeTmpDirIfEmpty(tmpDir);
+      this.archivePath = null;
     }
-    await rm2(this.archivePath, { force: true }).catch(() => {
-    });
-    this.log.info("Tree snapshot applied", {
-      treeHash: snapshot.treeHash,
-      totalChanges: snapshot.changes.length,
-      deletedFiles: snapshot.changes.filter((c) => c.status === "D").length
+  }
+  async removeTmpDirIfEmpty(tmpDir) {
+    const entries = await readdir(tmpDir).catch(() => null);
+    if (!entries || entries.length > 0) {
+      return;
+    }
+    await rmdir(tmpDir).catch(() => {
     });
-    return { treeHash: snapshot.treeHash };
   }
 };
 
 // src/sagas/capture-tree-saga.ts
 import { existsSync as existsSync2 } from "fs";
-import { readFile as readFile3, rm as rm3 } from "fs/promises";
+import { readdir as readdir2, readFile as readFile3, rm as rm3, rmdir as rmdir2 } from "fs/promises";
 import { join as join4 } from "path";
 var CaptureTreeSaga2 = class extends Saga {
   sagaName = "CaptureTreeSaga";
@@ -6176,54 +6191,62 @@ var CaptureTreeSaga2 = class extends Saga {
     }
     const shouldArchive = !!apiClient;
     const archivePath = shouldArchive ? join4(tmpDir, `tree-${Date.now()}.tar.gz`) : void 0;
-    const gitCaptureSaga = new CaptureTreeSaga(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;
-    if (apiClient && createdArchivePath) {
-      try {
-        archiveUrl = await this.uploadArchive(
-          createdArchivePath,
-          gitSnapshot.treeHash,
-          apiClient,
-          taskId,
-          runId
-        );
-      } finally {
-        await rm3(createdArchivePath, { force: true }).catch(() => {
+    try {
+      const gitCaptureSaga = new CaptureTreeSaga(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;
+      if (apiClient && createdArchivePath) {
+        try {
+          archiveUrl = await this.uploadArchive(
+            createdArchivePath,
+            gitSnapshot.treeHash,
+            apiClient,
+            taskId,
+            runId
+          );
+        } finally {
+          await rm3(createdArchivePath, { force: true }).catch(() => {
+          });
+        }
+      }
+      const snapshot = {
+        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 };
+    } finally {
+      if (archivePath) {
+        await rm3(archivePath, { force: true }).catch(() => {
         });
       }
+      await this.removeTmpDirIfEmpty(tmpDir);
     }
-    const snapshot = {
-      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 };
   }
   async uploadArchive(archivePath, treeHash, apiClient, taskId, runId) {
     const archiveUrl = await this.step({
@@ -6262,6 +6285,14 @@ var CaptureTreeSaga2 = class extends Saga {
     });
     return archiveUrl;
   }
+  async removeTmpDirIfEmpty(tmpDir) {
+    const entries = await readdir2(tmpDir).catch(() => null);
+    if (!entries || entries.length > 0) {
+      return;
+    }
+    await rmdir2(tmpDir).catch(() => {
+    });
+  }
 };
 
 // src/utils/logger.ts