feat: auto remove lock file

tiddly-gittly/TidGi-Desktop#574

Author: linonetwo

package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-sync-js",
-  "version": "2.2.1",
+  "version": "2.3.0",
   "description": "JS implementation for Git-Sync, a handy script that backup your notes in a git repo to the remote git services.",
   "homepage": "https://github.com/linonetwo/git-sync-js",
   "bugs": {

src/commitAndSync.ts

@@ -2,7 +2,7 @@ import { exec } from 'dugite';
 import { credentialOff, credentialOn } from './credential';
 import { defaultGitInfo as defaultDefaultGitInfo } from './defaultGitInfo';
 import { CantSyncGitNotInitializedError, GitPullPushError, SyncParameterMissingError } from './errors';
-import { assumeSync, getDefaultBranchName, getGitRepositoryState, getRemoteName, getSyncState, haveLocalChanges } from './inspect';
+import { assumeSync, getDefaultBranchName, getGitRepositoryState, getRemoteName, getSyncState, haveLocalChanges, removeGitLockFiles } from './inspect';
 import { GitStep, IGitUserInfos, ILogger } from './interface';
 import { commitFiles, continueRebase, fetchRemote, mergeUpstream, pushUpstream } from './sync';
 import { toGitStringResult } from './utils';
@@ -210,6 +210,12 @@ export async function syncPreflightCheck(configs: {
   const { dir, logger, logProgress, logDebug, defaultGitInfo = defaultDefaultGitInfo, userInfo } = configs;
   const { gitUserName, email } = userInfo ?? defaultGitInfo;
 
+  // Check and remove stale lock files before any git operations
+  const removedLockFiles = await removeGitLockFiles(dir, logger);
+  if (removedLockFiles > 0) {
+    logDebug?.(`Removed ${removedLockFiles} stale git lock file(s) before sync`, GitStep.PrepareSync);
+  }
+
   const repoStartingState = await getGitRepositoryState(dir, logger);
   if (repoStartingState.length === 0 || repoStartingState === '|DIRTY') {
     logProgress?.(GitStep.PrepareSync);

src/inspect.ts

@@ -73,7 +73,7 @@ export async function getRemoteUrl(dir: string, remoteName: string): Promise<str
   if (result.exitCode === 0 && result.stdout.trim().length > 0) {
     return result.stdout.trim();
   }
-  
+
   // Fallback: try to get the first remote if the specified one doesn't exist
   const remotesResult = toGitStringResult(await exec(['remote'], dir));
   if (remotesResult.exitCode === 0) {
@@ -86,7 +86,7 @@ export async function getRemoteUrl(dir: string, remoteName: string): Promise<str
       }
     }
   }
-  
+
   return '';
 }
 
@@ -343,3 +343,102 @@ export async function getRemoteName(dir: string, branch: string): Promise<string
   }
   return 'origin';
 }
+
+/**
+ * Check if there are stale git lock files and optionally remove them.
+ * Lock files can be left behind if git operations are interrupted.
+ *
+ * @param dir The git repository directory
+ * @param logger Optional logger for debugging
+ * @returns Array of lock file paths that were found
+ */
+export async function checkGitLockFiles(dir: string, logger?: ILogger): Promise<string[]> {
+  const logDebug = (message: string): unknown =>
+    logger?.debug(message, {
+      functionName: 'checkGitLockFiles',
+      step: GitStep.CheckingLocalGitRepoSanity,
+      dir,
+    });
+
+  try {
+    const gitDir = await getGitDirectory(dir);
+    const lockFiles = [
+      path.join(gitDir, 'index.lock'),
+      path.join(gitDir, 'HEAD.lock'),
+      path.join(gitDir, 'refs', 'heads', '*.lock'),
+      path.join(gitDir, 'refs', 'remotes', '*.lock'),
+    ];
+
+    const foundLockFiles: string[] = [];
+
+    for (const lockPattern of lockFiles) {
+      if (lockPattern.includes('*')) {
+        // Handle wildcard patterns - check parent directory
+        const parentDir = path.dirname(lockPattern);
+        if (await fs.pathExists(parentDir)) {
+          const files = await fs.readdir(parentDir);
+          for (const file of files) {
+            if (file.endsWith('.lock')) {
+              const fullPath = path.join(parentDir, file);
+              foundLockFiles.push(fullPath);
+              logDebug(`Found lock file: ${fullPath}`);
+            }
+          }
+        }
+      } else {
+        // Direct path check
+        if (await fs.pathExists(lockPattern)) {
+          foundLockFiles.push(lockPattern);
+          logDebug(`Found lock file: ${lockPattern}`);
+        }
+      }
+    }
+
+    return foundLockFiles;
+  } catch (error) {
+    logDebug(`Error checking lock files: ${(error as Error).message}`);
+    return [];
+  }
+}
+
+/**
+ * Remove stale git lock files that may block git operations.
+ * This should only be called when you're sure no other git operations are running.
+ *
+ * @param dir The git repository directory
+ * @param logger Optional logger for debugging
+ * @returns Number of lock files removed
+ */
+export async function removeGitLockFiles(dir: string, logger?: ILogger): Promise<number> {
+  const logDebug = (message: string): unknown =>
+    logger?.debug(message, {
+      functionName: 'removeGitLockFiles',
+      step: GitStep.CheckingLocalGitRepoSanity,
+      dir,
+    });
+  const logWarn = (message: string): unknown =>
+    logger?.warn?.(message, {
+      functionName: 'removeGitLockFiles',
+      step: GitStep.CheckingLocalGitRepoSanity,
+      dir,
+    });
+
+  const lockFiles = await checkGitLockFiles(dir, logger);
+  let removedCount = 0;
+
+  for (const lockFile of lockFiles) {
+    try {
+      await fs.remove(lockFile);
+      removedCount++;
+      logWarn(`Removed stale lock file: ${lockFile}`);
+    } catch (error) {
+      logDebug(`Failed to remove lock file ${lockFile}: ${(error as Error).message}`);
+    }
+  }
+
+  if (removedCount > 0) {
+    logWarn(`Removed ${removedCount} stale git lock file(s)`);
+  }
+
+  return removedCount;
+}

src/sync.ts

@@ -37,28 +37,31 @@ export async function commitFiles(
   logDebug(`Executing: git add . in ${dir}`, GitStep.AddingFiles);
   const addResult = toGitStringResult(await exec(['add', '.'], dir));
   logDebug(`git add exitCode: ${addResult.exitCode}, stdout: ${addResult.stdout || '(empty)'}, stderr: ${addResult.stderr || '(empty)'}`, GitStep.AddingFiles);
-  
+
   // Check what's actually in the staging area
   const statusResult = toGitStringResult(await exec(['status', '--porcelain'], dir));
   logDebug(`git status --porcelain: ${statusResult.stdout || '(empty)'}`, GitStep.AddingFiles);
-  
+
   // Check staged files using git diff --cached
   const diffCachedResult = toGitStringResult(await exec(['diff', '--cached', '--name-only'], dir));
   const actualStagedFiles = diffCachedResult.stdout.trim().split('\n').filter(f => f.length > 0);
   logDebug(`Actual staged files count (from git diff --cached): ${actualStagedFiles.length}`, GitStep.AddingFiles);
   if (actualStagedFiles.length > 0) {
-    logDebug(`Actual staged files: ${actualStagedFiles.slice(0, 10).join(', ')}${actualStagedFiles.length > 10 ? ` ... (${actualStagedFiles.length - 10} more)` : ''}`, GitStep.AddingFiles);
+    logDebug(
+      `Actual staged files: ${actualStagedFiles.slice(0, 10).join(', ')}${actualStagedFiles.length > 10 ? ` ... (${actualStagedFiles.length - 10} more)` : ''}`,
+      GitStep.AddingFiles,
+    );
   } else {
     logDebug('No files in staging area after git add!', GitStep.AddingFiles);
   }
-  
+
   // find and unStage files that are in the ignore list
   if (filesToIgnore.length > 0) {
     // Get all tracked files using git ls-files
     const lsFilesResult = toGitStringResult(await exec(['ls-files'], dir));
     const trackedFiles = lsFilesResult.stdout.trim().split('\n').filter(f => f.length > 0);
     logDebug(`Total tracked files count (from git ls-files): ${trackedFiles.length}`, GitStep.AddingFiles);
-    
+
     const stagedFilesToIgnore = filesToIgnore.filter((file) => trackedFiles.includes(file));
     logDebug(`Files to ignore count: ${filesToIgnore.length}, staged files to ignore count: ${stagedFilesToIgnore.length}`, GitStep.AddingFiles);
     if (stagedFilesToIgnore.length > 0) {
@@ -90,13 +93,13 @@ export async function commitFiles(
     ),
   );
   logDebug(`git commit exitCode: ${commitResult.exitCode}, stdout: ${commitResult.stdout || '(empty)'}, stderr: ${commitResult.stderr || '(empty)'}`, GitStep.CommitComplete);
-  
+
   if (commitResult.exitCode === 1 && commitResult.stdout.includes('nothing to commit')) {
     logDebug('Git commit reports "nothing to commit" - this is expected if staging area is empty', GitStep.CommitComplete);
   } else if (commitResult.exitCode === 128 && commitResult.stderr.includes('Committer identity unknown')) {
     logDebug('Git commit failed due to committer identity - this should not happen with env vars set', GitStep.CommitComplete);
   }
-  
+
   return commitResult;
 }
 

test/commitAndSync.test.ts

@@ -1,12 +1,12 @@
-import { omit } from 'lodash';
 import { exec } from 'dugite';
+import { omit } from 'lodash';
 import { commitAndSync, ICommitAndSyncOptions } from '../src/commitAndSync';
 import { defaultGitInfo } from '../src/defaultGitInfo';
 import { GitPullPushError } from '../src/errors';
 import { getRemoteUrl, getSyncState, SyncState } from '../src/inspect';
+import { toGitStringResult } from '../src/utils';
 import { creatorGitInfo, dir, exampleToken, upstreamDir } from './constants';
 import { addSomeFiles } from './utils';
-import { toGitStringResult } from '../src/utils';
 
 describe('commitAndSync', () => {
   const getCommitAndSyncOptions = (): ICommitAndSyncOptions => ({
@@ -50,15 +50,15 @@ fatal: Authentication failed for 'https://github.com/linonetwo/wiki/'
     // Add some files and commit
     await addSomeFiles();
     await commitAndSync(getCommitAndSyncOptions());
-    
+
     // Verify that both author and committer are set correctly
     const logResult = toGitStringResult(
       await exec(['log', '--format=%an|%ae|%cn|%ce', '-1'], dir),
     );
-    
+
     expect(logResult.exitCode).toBe(0);
     const [authorName, authorEmail, committerName, committerEmail] = logResult.stdout.trim().split('|');
-    
+
     // Both author and committer should be set to the same user info
     expect(authorName).toBe(defaultGitInfo.gitUserName);
     expect(authorEmail).toBe(defaultGitInfo.email);

test/lockFiles.test.ts

@@ -0,0 +1,82 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { checkGitLockFiles, removeGitLockFiles } from '../src/inspect';
+import { dir, gitDirectory } from './constants';
+
+describe('Git lock files', () => {
+  describe('checkGitLockFiles', () => {
+    test('returns empty array when no lock files exist', async () => {
+      const lockFiles = await checkGitLockFiles(dir);
+      expect(lockFiles).toEqual([]);
+    });
+
+    test('detects index.lock file', async () => {
+      const lockFilePath = path.join(gitDirectory, 'index.lock');
+      await fs.writeFile(lockFilePath, 'test lock file');
+
+      const lockFiles = await checkGitLockFiles(dir);
+      expect(lockFiles).toContain(lockFilePath);
+
+      // Clean up
+      await fs.remove(lockFilePath);
+    });
+
+    test('detects HEAD.lock file', async () => {
+      const lockFilePath = path.join(gitDirectory, 'HEAD.lock');
+      await fs.writeFile(lockFilePath, 'test lock file');
+
+      const lockFiles = await checkGitLockFiles(dir);
+      expect(lockFiles).toContain(lockFilePath);
+
+      // Clean up
+      await fs.remove(lockFilePath);
+    });
+
+    test('detects lock files in refs/heads', async () => {
+      const refsHeadsDir = path.join(gitDirectory, 'refs', 'heads');
+      await fs.mkdirp(refsHeadsDir);
+      const lockFilePath = path.join(refsHeadsDir, 'master.lock');
+      await fs.writeFile(lockFilePath, 'test lock file');
+
+      const lockFiles = await checkGitLockFiles(dir);
+      expect(lockFiles).toContain(lockFilePath);
+
+      // Clean up
+      await fs.remove(lockFilePath);
+    });
+  });
+
+  describe('removeGitLockFiles', () => {
+    test('removes index.lock file', async () => {
+      const lockFilePath = path.join(gitDirectory, 'index.lock');
+      await fs.writeFile(lockFilePath, 'test lock file');
+
+      const removedCount = await removeGitLockFiles(dir);
+      expect(removedCount).toBe(1);
+      expect(await fs.pathExists(lockFilePath)).toBe(false);
+    });
+
+    test('removes multiple lock files', async () => {
+      const indexLockPath = path.join(gitDirectory, 'index.lock');
+      const headLockPath = path.join(gitDirectory, 'HEAD.lock');
+      await fs.writeFile(indexLockPath, 'test lock file');
+      await fs.writeFile(headLockPath, 'test lock file');
+
+      const removedCount = await removeGitLockFiles(dir);
+      expect(removedCount).toBe(2);
+      expect(await fs.pathExists(indexLockPath)).toBe(false);
+      expect(await fs.pathExists(headLockPath)).toBe(false);
+    });
+
+    test('returns 0 when no lock files exist', async () => {
+      const removedCount = await removeGitLockFiles(dir);
+      expect(removedCount).toBe(0);
+    });
+
+    test('handles missing refs directories gracefully', async () => {
+      // This should not throw an error even if refs/heads doesn't exist
+      const removedCount = await removeGitLockFiles(dir);
+      expect(removedCount).toBeGreaterThanOrEqual(0);
+    });
+  });
+});