gdrive-syncer 3.1.1 → 3.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdrive-syncer",
-  "version": "3.1.1",
+  "version": "3.1.3",
   "description": "Google Drive Syncer",
   "main": "./index.js",
   "bin": "./run.js",

package/src/envSync.js

@@ -1242,54 +1242,19 @@ const runSyncOperation = async (syncConfig, action, projectRoot, backupPath, con
       }
     }
 
-    // Get local files first for delta sync comparison
+    // Get local files
     fs.ensureDirSync(envDir);
     const localItems = listLocalFilesRecursive(envDir, pattern, ignore, '', true);
     const localFiles = localItems.filter((f) => !f.isFolder);
     const localFolders = localItems.filter((f) => f.isFolder);
 
-    // Build local file lookup map for delta sync
-    const localFileMap = new Map();
-    for (const file of localFiles) {
-      localFileMap.set(file.relativePath, file);
-    }
-
-    // Delta sync: Determine which files need to be downloaded for comparison
-    // Skip files where metadata indicates no change (same size AND local is not older)
-    s.message('Analyzing file changes (delta sync)...');
-    const filesToDownload = [];
-    const unchangedFiles = [];
-
-    for (const driveFile of driveFiles) {
-      const localFile = localFileMap.get(driveFile.relativePath);
-
-      if (!localFile) {
-        // File only exists on Drive - need to download for diff
-        filesToDownload.push(driveFile);
-      } else {
-        // File exists in both places - check if metadata indicates change
-        const sizeMatch = driveFile.sizeBytes === localFile.sizeBytes;
-        const driveTime = driveFile.modifiedTime ? driveFile.modifiedTime.getTime() : 0;
-        const localTime = localFile.modifiedTime ? localFile.modifiedTime.getTime() : 0;
-
-        // Consider unchanged if: same size AND Drive is not newer
-        // (allow 1 second tolerance for time comparison)
-        const timeMatch = driveTime <= localTime + 1000;
-
-        if (sizeMatch && timeMatch) {
-          // Metadata suggests unchanged - skip download
-          unchangedFiles.push(driveFile.relativePath);
-        } else {
-          // Metadata differs - need to download for accurate comparison
-          filesToDownload.push(driveFile);
-        }
-      }
-    }
+    // Always download ALL Drive files for content-based comparison (no delta sync heuristics)
+    // Accuracy is paramount - metadata (size/time) comparisons are unreliable because:
+    // - Drive sizes from CLI output are human-readable approximations (lossy)
+    // - Local mtime vs Drive modifiedTime are not comparable across systems
+    const filesToDownload = [...driveFiles];
 
-    // Download only changed files to temp for comparison
-    s.message(
-      `Downloading ${filesToDownload.length} file(s) for comparison (${unchangedFiles.length} unchanged)...`
-    );
+    s.message(`Downloading ${filesToDownload.length} file(s) for comparison...`);
 
     // Prepare destination directories first
     for (const file of filesToDownload) {
@@ -1304,14 +1269,60 @@ const runSyncOperation = async (syncConfig, action, projectRoot, backupPath, con
         destination: path.join(tempDir, path.dirname(file.relativePath)),
         overwrite: true,
       },
+      relativePath: file.relativePath,
     }));
+    let downloadResults = [];
     if (downloads.length > 0) {
-      await gdrive.downloadParallel(downloads, 5, (completed, total) => {
+      downloadResults = await gdrive.downloadParallel(downloads, 5, (completed, total) => {
         s.message(`Downloading files for comparison... (${completed}/${total})`);
       });
     }
 
-    s.stop(color.green(`Found ${driveFiles.length} file(s) on Drive (${unchangedFiles.length} skipped via delta sync)`));
+    // Check for failed downloads and retry them individually
+    const failedDownloads = [];
+    for (let i = 0; i < downloadResults.length; i++) {
+      if (downloadResults[i].code !== 0) {
+        failedDownloads.push(downloads[i]);
+      }
+    }
+
+    if (failedDownloads.length > 0) {
+      s.message(`Retrying ${failedDownloads.length} failed download(s)...`);
+      for (const dl of failedDownloads) {
+        const retryResult = await gdrive.downloadAsync(dl.fileId, dl.options);
+        if (retryResult.code !== 0) {
+          // Verify file actually exists on disk despite error code
+          const expectedPath = path.join(tempDir, dl.relativePath);
+          if (!fs.existsSync(expectedPath)) {
+            s.stop(color.red('Download failures detected'));
+            log.error(`Failed to download: ${dl.relativePath}`);
+            if (retryResult.stderr) log.error(retryResult.stderr);
+            log.error('Diff results would be incomplete. Aborting to avoid showing incorrect diff.');
+            return;
+          }
+        }
+      }
+    }
+
+    // Final verification: ensure every file we expected to download actually exists
+    const missingFiles = [];
+    for (const file of filesToDownload) {
+      const expectedPath = path.join(tempDir, file.relativePath);
+      if (!fs.existsSync(expectedPath)) {
+        missingFiles.push(file.relativePath);
+      }
+    }
+
+    if (missingFiles.length > 0) {
+      s.stop(color.red('Some files could not be downloaded'));
+      for (const f of missingFiles) {
+        log.error(`Missing: ${f}`);
+      }
+      log.error('Diff results would be incomplete. Aborting to avoid showing incorrect diff.');
+      return;
+    }
+
+    s.stop(color.green(`Found ${driveFiles.length} file(s) on Drive, downloaded all for comparison`));
 
     // Compare files using relativePath
     const changes = {
@@ -1325,26 +1336,19 @@ const runSyncOperation = async (syncConfig, action, projectRoot, backupPath, con
     const driveFilePaths = new Set(driveFiles.map((f) => f.relativePath));
     const localFilePaths = new Set(localFiles.map((f) => f.relativePath));
     const localFolderPaths = new Set(localFolders.map((f) => f.relativePath));
-    const unchangedSet = new Set(unchangedFiles);
 
-    // Check local files
+    // Check local files - always compare content for accuracy
+    // All Drive files are guaranteed to exist in tempDir (verified above)
     for (const localFile of localFiles) {
       const localFilePath = path.join(envDir, localFile.relativePath);
       const driveFilePath = path.join(tempDir, localFile.relativePath);
 
       if (driveFilePaths.has(localFile.relativePath)) {
-        // File exists on both
-        if (unchangedSet.has(localFile.relativePath)) {
-          // Delta sync determined this file is unchanged - skip comparison
-          continue;
-        }
-        // Check for modifications (only for files we downloaded)
-        if (fs.existsSync(driveFilePath)) {
-          const localContent = fs.readFileSync(localFilePath, 'utf-8');
-          const driveContent = fs.readFileSync(driveFilePath, 'utf-8');
-          if (localContent !== driveContent) {
-            changes.modified.push(localFile.relativePath);
-          }
+        // File exists on both - compare actual content
+        const localContent = fs.readFileSync(localFilePath, 'utf-8');
+        const driveContent = fs.readFileSync(driveFilePath, 'utf-8');
+        if (localContent !== driveContent) {
+          changes.modified.push(localFile.relativePath);
         }
       } else {
         changes.localOnly.push(localFile.relativePath);
@@ -1519,11 +1523,13 @@ const runSyncOperation = async (syncConfig, action, projectRoot, backupPath, con
       }
 
       const downloadSpinner = spinner();
-      downloadSpinner.start('Downloading files...');
-
+      const totalToDownload = changes.modified.length + changes.driveOnly.length;
       let downloaded = 0;
 
+      downloadSpinner.start(`Downloading files... (0/${totalToDownload})`);
+
       for (const relativePath of changes.modified) {
+        downloadSpinner.message(`Downloading (${downloaded + 1}/${totalToDownload}): ${relativePath}`);
         const srcPath = path.join(tempDir, relativePath);
         const destPath = path.join(envDir, relativePath);
         fs.ensureDirSync(path.dirname(destPath));
@@ -1532,6 +1538,7 @@ const runSyncOperation = async (syncConfig, action, projectRoot, backupPath, con
       }
 
       for (const relativePath of changes.driveOnly) {
+        downloadSpinner.message(`Downloading (${downloaded + 1}/${totalToDownload}): ${relativePath}`);
         const srcPath = path.join(tempDir, relativePath);
         const destPath = path.join(envDir, relativePath);
         fs.ensureDirSync(path.dirname(destPath));
@@ -1542,11 +1549,13 @@ const runSyncOperation = async (syncConfig, action, projectRoot, backupPath, con
       downloadSpinner.stop(color.green(`Downloaded ${downloaded} file(s)`));
     } else if (action === 'upload') {
       const uploadSpinner = spinner();
-      uploadSpinner.start('Uploading files...');
-
+      const totalToUpload = changes.modified.length + changes.localOnly.length;
+      let completed = 0;
       let uploaded = 0;
       let replaced = 0;
 
+      uploadSpinner.start(`Uploading files... (0/${totalToUpload})`);
+
       // Build a map of relativePath -> driveFile for quick lookup
       const driveFileMap = new Map();
       for (const df of driveFiles) {
@@ -1554,14 +1563,17 @@ const runSyncOperation = async (syncConfig, action, projectRoot, backupPath, con
       }
 
       for (const relativePath of changes.modified) {
+        uploadSpinner.message(`Replacing (${completed + 1}/${totalToUpload}): ${relativePath}`);
         const driveFile = driveFileMap.get(relativePath);
         if (driveFile) {
           gdrive.update(driveFile.id, path.join(envDir, relativePath));
           replaced++;
+          completed++;
         }
       }
 
       for (const relativePath of changes.localOnly) {
+        uploadSpinner.message(`Uploading (${completed + 1}/${totalToUpload}): ${relativePath}`);
         const localFilePath = path.join(envDir, relativePath);
         const folderPath = path.dirname(relativePath);
 
@@ -1573,6 +1585,7 @@ const runSyncOperation = async (syncConfig, action, projectRoot, backupPath, con
 
         gdrive.upload(localFilePath, { parent: parentId });
         uploaded++;
+        completed++;
       }
 
       uploadSpinner.stop(color.green(`Replaced: ${replaced}, New: ${uploaded}`));