@posthog/agent 2.3.398 → 2.3.401

package/dist/server/bin.cjs

@@ -8729,7 +8729,7 @@ var import_zod3 = require("zod");
 // package.json
 var package_default = {
   name: "@posthog/agent",
-  version: "2.3.398",
+  version: "2.3.401",
   repository: "https://github.com/PostHog/code",
   description: "TypeScript agent framework wrapping Claude Agent SDK with Git-based task execution for PostHog",
   exports: {
@@ -19283,6 +19283,7 @@ var HandoffCheckpointTracker = class {
     } finally {
       await this.removeIfPresent(packPath);
       await this.removeIfPresent(indexPath);
+      await this.removeTmpDirIfEmpty(tmpDir);
     }
   }
   toGitCheckpoint(checkpoint) {
@@ -19441,6 +19442,14 @@ var HandoffCheckpointTracker = class {
     await (0, import_promises3.rm)(filePath, { force: true }).catch(() => {
     });
   }
+  async removeTmpDirIfEmpty(tmpDir) {
+    const entries = await (0, import_promises3.readdir)(tmpDir).catch(() => null);
+    if (!entries || entries.length > 0) {
+      return;
+    }
+    await (0, import_promises3.rmdir)(tmpDir).catch(() => {
+    });
+  }
 };
 
 // src/utils/gateway.ts
@@ -20605,62 +20614,77 @@ 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: () => (0, import_promises5.mkdir)(tmpDir, { recursive: true }),
-      rollback: async () => {
-      }
-    });
-    const archivePath = (0, import_node_path8.join)(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: () => (0, import_promises5.mkdir)(tmpDir, { recursive: true }),
+        rollback: async () => {
         }
-        const base64Content = Buffer.from(arrayBuffer).toString("utf-8");
-        const binaryContent = Buffer.from(base64Content, "base64");
-        await (0, import_promises5.writeFile)(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 (0, import_promises5.rm)(this.archivePath, { force: true }).catch(() => {
+      });
+      const archivePath = (0, import_node_path8.join)(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 (0, import_promises5.writeFile)(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 (0, import_promises5.rm)(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 (0, import_promises5.rm)(this.archivePath, { force: true }).catch(() => {
+        });
+      }
+      await this.removeTmpDirIfEmpty(tmpDir);
+      this.archivePath = null;
     }
-    await (0, import_promises5.rm)(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 (0, import_promises5.readdir)(tmpDir).catch(() => null);
+    if (!entries || entries.length > 0) {
+      return;
+    }
+    await (0, import_promises5.rmdir)(tmpDir).catch(() => {
     });
-    return { treeHash: snapshot.treeHash };
   }
 };
 
@@ -20687,54 +20711,62 @@ var CaptureTreeSaga2 = class extends Saga {
     }
     const shouldArchive = !!apiClient;
     const archivePath = shouldArchive ? (0, import_node_path9.join)(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 (0, import_promises6.rm)(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 (0, import_promises6.rm)(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 (0, import_promises6.rm)(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({
@@ -20773,6 +20805,14 @@ var CaptureTreeSaga2 = class extends Saga {
     });
     return archiveUrl;
   }
+  async removeTmpDirIfEmpty(tmpDir) {
+    const entries = await (0, import_promises6.readdir)(tmpDir).catch(() => null);
+    if (!entries || entries.length > 0) {
+      return;
+    }
+    await (0, import_promises6.rmdir)(tmpDir).catch(() => {
+    });
+  }
 };
 
 // src/tree-tracker.ts