sync-worktrees 3.3.0 → 3.4.0

package/dist/index.js

@@ -55,7 +55,11 @@ var DEFAULT_CONFIG = {
     MAX_SAFE_TOTAL_CONCURRENT_OPS: 100
   },
   UPDATE_EXISTING_WORKTREES: true,
-  HOOK_TIMEOUT_MS: 6e4
+  HOOK_TIMEOUT_MS: 6e4,
+  FETCH_TIMEOUT_MS: 3e5,
+  CLONE_TIMEOUT_MS: 9e5,
+  LOCK_STALE_MS: 6e5,
+  LOCK_UPDATE_MS: 3e4
 };
 var ERROR_MESSAGES = {
   GIT_NOT_INITIALIZED: "Git service not initialized. Call initialize() first.",
@@ -1947,6 +1951,7 @@ var App_default = App;
 import * as fs6 from "fs/promises";
 import * as path7 from "path";
 import pLimit from "p-limit";
+import * as lockfile from "proper-lockfile";
 
 // src/utils/date-filter.ts
 function parseDuration(durationStr) {
@@ -2993,6 +2998,13 @@ var WorktreeStatusService = class {
 };
 
 // src/services/git.service.ts
+function sanitizeGitEnv(env) {
+  const sanitized = { ...env };
+  delete sanitized.EDITOR;
+  delete sanitized.GIT_EDITOR;
+  delete sanitized.GIT_SEQUENCE_EDITOR;
+  return sanitized;
+}
 var GitService = class {
   constructor(config, logger) {
     this.config = config;
@@ -3017,11 +3029,21 @@ var GitService = class {
   getSparseCheckoutService() {
     return this.sparseCheckoutService;
   }
+  getFetchTimeoutMs() {
+    if (process.env.NODE_ENV === ENV_CONSTANTS.NODE_ENV_TEST) return 0;
+    return this.config.fetchTimeoutMs ?? DEFAULT_CONFIG.FETCH_TIMEOUT_MS;
+  }
+  getCloneTimeoutMs() {
+    if (process.env.NODE_ENV === ENV_CONSTANTS.NODE_ENV_TEST) return 0;
+    return this.config.cloneTimeoutMs ?? DEFAULT_CONFIG.CLONE_TIMEOUT_MS;
+  }
   getCachedGit(dirPath, useLfsSkip = false) {
     const key = `${path5.resolve(dirPath)}::${useLfsSkip ? "1" : "0"}`;
     let git = this.gitInstances.get(key);
     if (!git) {
-      git = useLfsSkip ? simpleGit4(dirPath).env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }) : simpleGit4(dirPath);
+      const block = this.getFetchTimeoutMs();
+      const base = block > 0 ? simpleGit4(dirPath, { timeout: { block } }) : simpleGit4(dirPath);
+      git = useLfsSkip ? base.env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }) : base;
       this.gitInstances.set(key, git);
     }
     return git;
@@ -3037,7 +3059,9 @@ var GitService = class {
     } catch {
       this.logger.info(`Cloning from "${repoUrl}" as bare repository into "${this.bareRepoPath}"...`);
       await fs4.mkdir(path5.dirname(this.bareRepoPath), { recursive: true });
-      const cloneGit = this.isLfsSkipEnabled() ? simpleGit4().env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }) : simpleGit4();
+      const cloneBlock = this.getCloneTimeoutMs();
+      const cloneBase = cloneBlock > 0 ? simpleGit4({ timeout: { block: cloneBlock } }) : simpleGit4();
+      const cloneGit = this.isLfsSkipEnabled() ? cloneBase.env({ [ENV_CONSTANTS.GIT_LFS_SKIP_SMUDGE]: "1" }) : cloneBase;
       await cloneGit.clone(repoUrl, this.bareRepoPath, ["--bare"]);
       this.logger.info("\u2705 Clone successful.");
     }
@@ -3123,6 +3147,9 @@ var GitService = class {
   getDefaultBranch() {
     return this.defaultBranch;
   }
+  getBareRepoPath() {
+    return this.bareRepoPath;
+  }
   async fetchAll() {
     this.assertInitialized();
     this.logger.info("Fetching latest data from remote...");
@@ -3169,7 +3196,7 @@ var GitService = class {
     return branches;
   }
   async verifyLfsFilesDownloaded(worktreePath, branchName) {
-    const worktreeGit = this.config.sparseCheckout ? simpleGit4(worktreePath).env({ ...process.env, [ENV_CONSTANTS.GIT_ATTR_SOURCE]: "HEAD" }) : this.getCachedGit(worktreePath);
+    const worktreeGit = this.config.sparseCheckout ? simpleGit4(worktreePath).env({ ...sanitizeGitEnv(process.env), [ENV_CONSTANTS.GIT_ATTR_SOURCE]: "HEAD" }) : this.getCachedGit(worktreePath);
     try {
       const lfsFiles = await worktreeGit.raw(["lfs", "ls-files", "--name-only"]);
       let lfsFileList = lfsFiles.trim().split("\n").filter((f) => f.length > 0);
@@ -3832,6 +3859,11 @@ var WorktreeSyncService = class {
       this.logger.warn("\u26A0\uFE0F  Sync already in progress, skipping...");
       return { started: false, reason: "in_progress" };
     }
+    const release = await this.acquireBareLock();
+    if (release === null) {
+      this.logger.warn("\u26A0\uFE0F  Another process holds the sync lock for this repo, skipping...");
+      return { started: false, reason: "locked" };
+    }
     this.syncInProgress = true;
     this.logger.info(`[${(/* @__PURE__ */ new Date()).toISOString()}] Starting worktree synchronization...`);
     const totalTimer = new Timer();
@@ -3848,6 +3880,11 @@ var WorktreeSyncService = class {
         this.gitService.setLfsSkipEnabled(false);
       }
       this.syncInProgress = false;
+      try {
+        await release();
+      } catch (releaseError) {
+        this.logger.warn(`Failed to release sync lock: ${getErrorMessage(releaseError)}`);
+      }
       this.logger.info(`[${(/* @__PURE__ */ new Date()).toISOString()}] Synchronization finished.
 `);
       if (this.config.debug) {
@@ -3859,6 +3896,39 @@ var WorktreeSyncService = class {
     }
     return { started: true };
   }
+  async acquireBareLock() {
+    if (process.env.NODE_ENV === ENV_CONSTANTS.NODE_ENV_TEST) {
+      return async () => {
+      };
+    }
+    if (typeof this.gitService.getBareRepoPath !== "function") {
+      return async () => {
+      };
+    }
+    const barePath = this.gitService.getBareRepoPath();
+    const lockTarget = path7.join(barePath, "HEAD");
+    try {
+      await fs6.access(lockTarget);
+    } catch {
+      return async () => {
+      };
+    }
+    try {
+      const release = await lockfile.lock(lockTarget, {
+        stale: DEFAULT_CONFIG.LOCK_STALE_MS,
+        update: DEFAULT_CONFIG.LOCK_UPDATE_MS,
+        retries: 0,
+        realpath: false
+      });
+      return release;
+    } catch (error) {
+      const code = error.code;
+      if (code === "ELOCKED") {
+        return null;
+      }
+      throw error;
+    }
+  }
   createRetryOptions(syncContext) {
     return {
       maxAttempts: this.config.retry?.maxAttempts ?? 3,