@posthog/agent 2.3.401 → 2.3.403

package/dist/handoff-checkpoint.d.ts

@@ -34,11 +34,8 @@ declare class HandoffCheckpointTracker {
     private createGitTracker;
     private logCaptureMetrics;
     private logApplyMetrics;
-    private buildMetricPayload;
     private sumRawBytes;
-    private sumWireBytes;
     private removeIfPresent;
-    private removeTmpDirIfEmpty;
 }
 
 export { HandoffCheckpointTracker, type HandoffCheckpointTrackerConfig };

package/dist/handoff-checkpoint.js

@@ -897,19 +897,14 @@ var require_dist2 = __commonJS({
 });
 
 // src/handoff-checkpoint.ts
-import {
-  mkdir as mkdir3,
-  readdir,
-  readFile as readFile2,
-  rm as rm3,
-  rmdir,
-  writeFile
-} from "fs/promises";
-import { join as join2 } from "path";
+import { mkdtemp as mkdtemp2, readFile as readFile2, rm as rm3, writeFile } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { dirname, join as join2 } from "path";
 
 // ../git/dist/handoff.js
 import { spawn as spawn2 } from "child_process";
-import { copyFile, mkdir as mkdir2, readFile, rm as rm2, stat as stat2 } from "fs/promises";
+import { copyFile, mkdtemp, readFile, rm as rm2, stat as stat2 } from "fs/promises";
+import { tmpdir } from "os";
 import path3 from "path";
 
 // ../../node_modules/simple-git/dist/esm/index.js
@@ -6055,7 +6050,7 @@ var GitHandoffTracker = class {
     this.repositoryPath = config.repositoryPath;
     this.logger = config.logger;
   }
-  async captureForHandoff(localGitState) {
+  async captureForHandoff(_localGitState) {
     const captureSaga = new CaptureCheckpointSaga(this.logger);
     const result = await captureSaga.run({ baseDir: this.repositoryPath });
     if (!result.success) {
@@ -6063,15 +6058,19 @@ var GitHandoffTracker = class {
     }
     const checkpoint = result.data;
     const git = createGitClient(this.repositoryPath);
-    const tempDir = await this.getTempDir(git);
+    const tempDir = await this.createTempDir(checkpoint.checkpointId);
     const checkpointRef = `${CHECKPOINT_REF_PREFIX2}${checkpoint.checkpointId}`;
-    const shouldIncludeHead = !!checkpoint.head && checkpoint.head !== localGitState?.head;
-    const headRef = shouldIncludeHead ? `${HANDOFF_HEAD_REF_PREFIX}${checkpoint.checkpointId}` : void 0;
+    const packRefs = [
+      checkpoint.head,
+      checkpoint.indexTree,
+      checkpoint.worktreeTree
+    ].filter((ref) => !!ref);
+    const headRef = checkpoint.head ? `${HANDOFF_HEAD_REF_PREFIX}${checkpoint.checkpointId}` : void 0;
     const packPrefix = path3.join(tempDir, checkpoint.checkpointId);
     try {
       const [headPack, indexFile, tracking] = await Promise.all([
-        shouldIncludeHead && checkpoint.head ? this.captureHeadPack(packPrefix, checkpoint.head) : Promise.resolve(void 0),
-        this.copyIndexFile(git, checkpoint.checkpointId),
+        this.captureObjectPack(packPrefix, packRefs),
+        this.copyIndexFile(git, checkpoint.checkpointId, tempDir),
         getTrackingMetadata(git, checkpoint.branch)
       ]);
       return {
@@ -6118,6 +6117,8 @@ var GitHandoffTracker = class {
     } else if (checkpoint.head) {
       await git.checkout(checkpoint.head);
     }
+    await git.clean(["f", "d"]);
+    await git.raw(["read-tree", "--reset", "-u", checkpoint.worktreeTree]);
     if (indexPath) {
       await this.restoreIndexFile(git, indexPath);
     }
@@ -6129,8 +6130,8 @@ var GitHandoffTracker = class {
       totalBytes: packBytes + indexBytes
     };
   }
-  async captureHeadPack(packPrefix, headCommit) {
-    const hash = await this.runGitWithInput(["pack-objects", packPrefix, "--revs"], `${headCommit}
+  async captureObjectPack(packPrefix, refs) {
+    const hash = await this.runGitWithInput(["pack-objects", packPrefix, "--revs"], `${refs.join("\n")}
 `);
     const packPath = `${packPrefix}-${hash.trim()}.pack`;
     const rawBytes = await this.getFileSize(packPath);
@@ -6138,9 +6139,8 @@ var GitHandoffTracker = class {
     });
     return { path: packPath, rawBytes };
   }
-  async copyIndexFile(git, checkpointId) {
+  async copyIndexFile(git, checkpointId, tempDir) {
     const indexPath = await this.getGitPath(git, "index");
-    const tempDir = await this.getTempDir(git);
     const copiedIndexPath = path3.join(tempDir, `${checkpointId}.index`);
     await copyFile(indexPath, copiedIndexPath);
     return {
@@ -6268,13 +6268,8 @@ var GitHandoffTracker = class {
     ]);
     return exitCode === 0;
   }
-  async getTempDir(git) {
-    const raw = await git.raw(["rev-parse", "--git-common-dir"]);
-    const commonDir = raw.trim() || ".git";
-    const resolved = path3.isAbsolute(commonDir) ? commonDir : path3.resolve(this.repositoryPath, commonDir);
-    const tempDir = path3.join(resolved, "posthog-code-tmp");
-    await mkdir2(tempDir, { recursive: true });
-    return tempDir;
+  async createTempDir(checkpointId) {
+    return mkdtemp(joinTempPrefix(checkpointId));
   }
   async getGitPath(git, gitPath) {
     const raw = await git.raw(["rev-parse", "--git-path", gitPath]);
@@ -6341,6 +6336,9 @@ var GitHandoffTracker = class {
     });
   }
 };
+function joinTempPrefix(checkpointId) {
+  return path3.join(tmpdir(), `posthog-code-handoff-${checkpointId}-`);
+}
 async function getCurrentBranchName(git) {
   try {
     const raw = await git.revparse(["--abbrev-ref", "HEAD"]);
@@ -6480,8 +6478,11 @@ var HandoffCheckpointTracker = class {
         indexArtifactPath: uploads.index?.storagePath
       };
     } finally {
+      const tempDir = capture.headPack?.path ? dirname(capture.headPack.path) : dirname(capture.indexFile.path);
       await this.removeIfPresent(capture.headPack?.path);
       await this.removeIfPresent(capture.indexFile.path);
+      await rm3(tempDir, { recursive: true, force: true }).catch(() => {
+      });
     }
   }
   async applyFromHandoff(checkpoint, options) {
@@ -6491,8 +6492,9 @@ var HandoffCheckpointTracker = class {
       );
     }
     const gitTracker = this.createGitTracker();
-    const tmpDir = join2(this.repositoryPath, ".posthog", "tmp");
-    await mkdir3(tmpDir, { recursive: true });
+    const tmpDir = await mkdtemp2(
+      join2(tmpdir2(), `posthog-code-handoff-${checkpoint.checkpointId}-`)
+    );
     const packPath = join2(tmpDir, `${checkpoint.checkpointId}.pack`);
     const indexPath = join2(tmpDir, `${checkpoint.checkpointId}.index`);
     try {
@@ -6526,7 +6528,8 @@ var HandoffCheckpointTracker = class {
     } finally {
       await this.removeIfPresent(packPath);
       await this.removeIfPresent(indexPath);
-      await this.removeTmpDirIfEmpty(tmpDir);
+      await rm3(tmpDir, { recursive: true, force: true }).catch(() => {
+      });
     }
   }
   toGitCheckpoint(checkpoint) {
@@ -6634,50 +6637,24 @@ var HandoffCheckpointTracker = class {
   }
   logCaptureMetrics(checkpoint, uploads) {
     this.logger.info("Captured handoff checkpoint", {
-      checkpointId: checkpoint.checkpointId,
       branch: checkpoint.branch,
-      head: checkpoint.head,
-      artifactPath: uploads.pack?.storagePath,
-      indexArtifactPath: uploads.index?.storagePath,
-      ...this.buildMetricPayload(uploads)
+      head: checkpoint.head?.slice(0, 7),
+      totalBytes: this.sumRawBytes(uploads.pack, uploads.index)
     });
   }
-  logApplyMetrics(checkpoint, downloads, totalBytes) {
+  logApplyMetrics(checkpoint, _downloads, totalBytes) {
     this.logger.info("Applied handoff checkpoint", {
-      checkpointId: checkpoint.checkpointId,
-      commit: checkpoint.commit,
       branch: checkpoint.branch,
-      head: checkpoint.head,
-      packBytes: downloads.pack?.rawBytes ?? 0,
-      packWireBytes: downloads.pack?.wireBytes ?? 0,
-      indexBytes: downloads.index?.rawBytes ?? 0,
-      indexWireBytes: downloads.index?.wireBytes ?? 0,
-      totalBytes,
-      totalWireBytes: this.sumWireBytes(downloads.pack, downloads.index)
+      head: checkpoint.head?.slice(0, 7),
+      totalBytes
     });
   }
-  buildMetricPayload(metrics) {
-    return {
-      packBytes: metrics.pack?.rawBytes ?? 0,
-      packWireBytes: metrics.pack?.wireBytes ?? 0,
-      indexBytes: metrics.index?.rawBytes ?? 0,
-      indexWireBytes: metrics.index?.wireBytes ?? 0,
-      totalBytes: this.sumRawBytes(metrics.pack, metrics.index),
-      totalWireBytes: this.sumWireBytes(metrics.pack, metrics.index)
-    };
-  }
   sumRawBytes(...artifacts) {
     return artifacts.reduce(
       (total, artifact) => total + (artifact?.rawBytes ?? 0),
       0
     );
   }
-  sumWireBytes(...artifacts) {
-    return artifacts.reduce(
-      (total, artifact) => total + (artifact?.wireBytes ?? 0),
-      0
-    );
-  }
   async removeIfPresent(filePath) {
     if (!filePath) {
       return;
@@ -6685,14 +6662,6 @@ var HandoffCheckpointTracker = class {
     await rm3(filePath, { force: true }).catch(() => {
     });
   }
-  async removeTmpDirIfEmpty(tmpDir) {
-    const entries = await readdir(tmpDir).catch(() => null);
-    if (!entries || entries.length > 0) {
-      return;
-    }
-    await rmdir(tmpDir).catch(() => {
-    });
-  }
 };
 export {
   HandoffCheckpointTracker