gdrive-syncer 2.2.0 → 3.1.0

package/src/envSync.js

@@ -2,6 +2,7 @@
 
 const shell = require('shelljs');
 const fs = require('fs-extra');
+const gdrive = require('./gdriveCmd');
 const path = require('path');
 const os = require('os');
 const { select, multiselect, text, isCancel, cancel, spinner, confirm, note, log } = require('@clack/prompts');
@@ -564,6 +565,168 @@ const envShow = async () => {
   }
 };
 
+/**
+ * Recursively list files and folders from Google Drive
+ * @param {string} folderId - Root folder ID
+ * @param {string} pattern - File pattern to match
+ * @param {string} [ignore] - Ignore pattern
+ * @param {string} [prefix=''] - Path prefix for nested files
+ * @param {boolean} [includeFolders=false] - Whether to include folders in results
+ * @returns {Array<{id: string, name: string, relativePath: string, isFolder: boolean}>}
+ */
+const listDriveFilesRecursive = (folderId, pattern, ignore, prefix = '', includeFolders = false) => {
+  const results = [];
+
+  const listResult = gdrive.list({
+    query: `'${folderId}' in parents and trashed = false`,
+    noHeader: true,
+    max: 1000,
+  });
+
+  if (listResult.code !== 0) {
+    return results;
+  }
+
+  const stdout = listResult.stdout.trim();
+  if (!stdout) return results;
+
+  const parsed = gdrive.parseListOutput(stdout);
+
+  for (const file of parsed) {
+    if (!file.id || !file.name) continue;
+
+    const relativePath = prefix ? `${prefix}/${file.name}` : file.name;
+    const isFolder = file.type && file.type.toLowerCase().includes('folder');
+
+    if (isFolder) {
+      // Add folder to results if requested
+      if (includeFolders) {
+        results.push({
+          id: file.id,
+          name: file.name,
+          relativePath,
+          isFolder: true,
+        });
+      }
+      // Recursively list folder contents
+      const subFiles = listDriveFilesRecursive(file.id, pattern, ignore, relativePath, includeFolders);
+      results.push(...subFiles);
+    } else {
+      // Only add files that match the pattern
+      if (matchPattern(file.name, pattern, ignore)) {
+        results.push({
+          id: file.id,
+          name: file.name,
+          relativePath,
+          isFolder: false,
+        });
+      }
+    }
+  }
+
+  return results;
+};
+
+/**
+ * Recursively list local files and folders
+ * @param {string} dir - Directory to list
+ * @param {string} pattern - File pattern to match
+ * @param {string} [ignore] - Ignore pattern
+ * @param {string} [prefix=''] - Path prefix for nested files
+ * @param {boolean} [includeFolders=false] - Whether to include folders in results
+ * @returns {Array<{name: string, relativePath: string, isFolder: boolean}>}
+ */
+const listLocalFilesRecursive = (dir, pattern, ignore, prefix = '', includeFolders = false) => {
+  const results = [];
+
+  if (!fs.existsSync(dir)) {
+    return results;
+  }
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+
+    if (entry.isDirectory()) {
+      // Add folder to results if requested
+      if (includeFolders) {
+        results.push({
+          name: entry.name,
+          relativePath,
+          isFolder: true,
+        });
+      }
+      // Recursively list subdirectory
+      const subDir = path.join(dir, entry.name);
+      const subFiles = listLocalFilesRecursive(subDir, pattern, ignore, relativePath, includeFolders);
+      results.push(...subFiles);
+    } else if (entry.isFile()) {
+      // Only add files that match the pattern
+      if (matchPattern(entry.name, pattern, ignore)) {
+        results.push({
+          name: entry.name,
+          relativePath,
+          isFolder: false,
+        });
+      }
+    }
+  }
+
+  return results;
+};
+
+/**
+ * Find or create a folder in Google Drive by path
+ * @param {string} parentId - Parent folder ID
+ * @param {string} folderPath - Folder path like "a/b/c"
+ * @returns {string} - The folder ID of the deepest folder
+ */
+const findOrCreateDriveFolder = (parentId, folderPath) => {
+  const parts = folderPath.split('/').filter(Boolean);
+  let currentParentId = parentId;
+
+  for (const folderName of parts) {
+    // Check if folder exists
+    const listResult = gdrive.list({
+      query: `'${currentParentId}' in parents and name = '${folderName}' and mimeType = 'application/vnd.google-apps.folder' and trashed = false`,
+      noHeader: true,
+      max: 1,
+    });
+
+    let folderId = null;
+
+    if (listResult.code === 0 && listResult.stdout.trim()) {
+      const parsed = gdrive.parseListOutput(listResult.stdout.trim());
+      if (parsed.length > 0 && parsed[0].id) {
+        folderId = parsed[0].id;
+      }
+    }
+
+    if (!folderId) {
+      // Create the folder
+      const mkdirResult = gdrive.mkdir(folderName, { parent: currentParentId });
+      if (mkdirResult.code === 0) {
+        // Parse the created folder ID from output
+        // gdrive@3 outputs: "Directory created: ID"
+        // gdrive@2 outputs: "Directory ID created"
+        const match = mkdirResult.stdout.match(/([a-zA-Z0-9_-]{20,})/);
+        if (match) {
+          folderId = match[1];
+        }
+      }
+    }
+
+    if (!folderId) {
+      throw new Error(`Failed to find or create folder: ${folderName}`);
+    }
+
+    currentParentId = folderId;
+  }
+
+  return currentParentId;
+};
+
 /**
  * Convert a glob pattern to a regex pattern
  * Supports:
@@ -739,6 +902,10 @@ const envRun = async (presetAction, presetConfigType) => {
         log.error('No syncs in global config.');
         return;
       }
+      if (presetConfigType === 'registered' && registeredRefs.length === 0) {
+        log.error('No registered local configs found.');
+        return;
+      }
       configType = presetConfigType;
       log.info(`Using ${configType} config`);
     } else {
@@ -903,81 +1070,101 @@ const runSyncOperation = async (syncConfig, action, projectRoot, backupPath, con
   fs.ensureDirSync(tempDir);
 
   try {
-    // Fetch file list from Drive
+    // Fetch file list from Drive (recursive, including folders for cleanup)
     const s = spinner();
-    s.start('Fetching files from Google Drive...');
-
-    const listResult = shell.exec(`gdrive list -q "'${folderId}' in parents" --no-header`, {
-      silent: true,
-    });
-
-    if (listResult.code !== 0) {
-      s.stop(color.red('Failed to fetch from Drive'));
-      log.error('Could not list files from Google Drive. Check folder ID and permissions.');
-      if (listResult.stderr) log.error(listResult.stderr);
-      return;
-    }
-
-    const driveFiles = [];
-    const stdout = listResult.stdout.trim();
-    if (stdout) {
-      stdout.split('\n').forEach((line) => {
-        // gdrive output format: ID   NAME   TYPE   SIZE   DATE
-        // Split by 2+ spaces to handle filenames with single spaces
-        const parts = line.trim().split(/\s{2,}/);
-        if (parts.length >= 2) {
-          const fileId = parts[0].trim();
-          const fileName = parts[1].trim();
-          if (matchPattern(fileName, pattern, ignore)) {
-            driveFiles.push({ id: fileId, name: fileName });
-          }
-        }
+    s.start('Fetching files from Google Drive (including nested folders)...');
+
+    const driveItems = listDriveFilesRecursive(folderId, pattern, ignore, '', true);
+    const driveFiles = driveItems.filter((f) => !f.isFolder);
+    const driveFolders = driveItems.filter((f) => f.isFolder);
+
+    if (driveFiles.length === 0) {
+      // Check if the folder exists at all
+      const testResult = gdrive.list({
+        query: `'${folderId}' in parents and trashed = false`,
+        noHeader: true,
+        max: 1,
       });
+      if (testResult.code !== 0) {
+        s.stop(color.red('Failed to fetch from Drive'));
+        log.error('Could not list files from Google Drive. Check folder ID and permissions.');
+        if (testResult.stderr) log.error(testResult.stderr);
+        return;
+      }
     }
 
-    // Download Drive files to temp for comparison
+    // Download Drive files to temp for comparison (preserving folder structure)
     s.message('Downloading Drive files for comparison...');
     for (const file of driveFiles) {
-      shell.exec(`gdrive download "${file.id}" --path "${tempDir}" --force`, { silent: true });
+      const destPath = path.join(tempDir, path.dirname(file.relativePath));
+      fs.ensureDirSync(destPath);
+      gdrive.download(file.id, { destination: destPath, overwrite: true });
     }
     s.stop(color.green(`Found ${driveFiles.length} matching file(s) on Drive`));
 
-    // Get local files
+    // Get local files (recursive, including folders for cleanup)
     fs.ensureDirSync(envDir);
-    const localFiles = fs.readdirSync(envDir).filter((f) => matchPattern(f, pattern, ignore));
+    const localItems = listLocalFilesRecursive(envDir, pattern, ignore, '', true);
+    const localFiles = localItems.filter((f) => !f.isFolder);
+    const localFolders = localItems.filter((f) => f.isFolder);
 
-    // Compare files
+    // Compare files using relativePath
     const changes = {
       modified: [],
       localOnly: [],
       driveOnly: [],
+      orphanDriveFolders: [], // Folders on Drive with no local equivalent
     };
 
+    // Build a set of drive file paths for quick lookup
+    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));
+
     // Check local files
-    for (const filename of localFiles) {
-      const localFile = path.join(envDir, filename);
-      const driveFile = path.join(tempDir, filename);
-
-      if (fs.existsSync(driveFile)) {
-        const localContent = fs.readFileSync(localFile, 'utf-8');
-        const driveContent = fs.readFileSync(driveFile, 'utf-8');
-        if (localContent !== driveContent) {
-          changes.modified.push(filename);
+    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 - check for modifications
+        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);
+          }
         }
       } else {
-        changes.localOnly.push(filename);
+        changes.localOnly.push(localFile.relativePath);
       }
     }
 
     // Check Drive-only files
-    for (const file of driveFiles) {
-      if (!localFiles.includes(file.name)) {
-        changes.driveOnly.push(file.name);
+    for (const driveFile of driveFiles) {
+      if (!localFilePaths.has(driveFile.relativePath)) {
+        changes.driveOnly.push(driveFile.relativePath);
+      }
+    }
+
+    // Check for orphan Drive folders (folders on Drive with no local equivalent)
+    for (const driveFolder of driveFolders) {
+      if (!localFolderPaths.has(driveFolder.relativePath)) {
+        // Only mark as orphan if no local files exist under this folder path
+        const hasLocalFilesUnder = localFiles.some((f) =>
+          f.relativePath.startsWith(driveFolder.relativePath + '/')
+        );
+        if (!hasLocalFilesUnder) {
+          changes.orphanDriveFolders.push(driveFolder);
+        }
       }
     }
 
     const hasChanges =
-      changes.modified.length > 0 || changes.localOnly.length > 0 || changes.driveOnly.length > 0;
+      changes.modified.length > 0 ||
+      changes.localOnly.length > 0 ||
+      changes.driveOnly.length > 0 ||
+      changes.orphanDriveFolders.length > 0;
 
     if (!hasChanges) {
       log.success('No changes detected. Local and Drive are in sync.');
@@ -991,21 +1178,21 @@ const runSyncOperation = async (syncConfig, action, projectRoot, backupPath, con
     log.info(color.bold('Changes Preview:'));
     console.log('');
 
-    for (const filename of changes.modified) {
-      const localFile = path.join(envDir, filename);
-      const driveFile = path.join(tempDir, filename);
+    for (const relativePath of changes.modified) {
+      const localFilePath = path.join(envDir, relativePath);
+      const driveFilePath = path.join(tempDir, relativePath);
       // Swap order based on action: upload shows drive->local, download shows local->drive
       const diffResult = isUpload
-        ? shell.exec(`diff -u "${driveFile}" "${localFile}"`, { silent: true })
-        : shell.exec(`diff -u "${localFile}" "${driveFile}"`, { silent: true });
+        ? shell.exec(`diff -u "${driveFilePath}" "${localFilePath}"`, { silent: true })
+        : shell.exec(`diff -u "${localFilePath}" "${driveFilePath}"`, { silent: true });
 
       if (diffResult.stdout) {
         const lines = diffResult.stdout.split('\n');
         lines.forEach((line) => {
           if (line.startsWith('---')) {
-            console.log(color.cyan(`--- ${filename} (${isUpload ? 'Drive' : 'Local'})`));
+            console.log(color.cyan(`--- ${relativePath} (${isUpload ? 'Drive' : 'Local'})`));
           } else if (line.startsWith('+++')) {
-            console.log(color.cyan(`+++ ${filename} (${isUpload ? 'Local' : 'Drive'})`));
+            console.log(color.cyan(`+++ ${relativePath} (${isUpload ? 'Local' : 'Drive'})`));
           } else if (line.startsWith('@@')) {
             console.log(color.cyan(line));
           } else if (line.startsWith('-')) {
@@ -1020,30 +1207,71 @@ const runSyncOperation = async (syncConfig, action, projectRoot, backupPath, con
       }
     }
 
-    for (const filename of changes.localOnly) {
-      console.log(color.cyan(`--- /dev/null`));
-      console.log(color.cyan(`+++ ${filename} (Local only)`));
-      console.log(color.green(`  [New local file - will be uploaded]`));
+    for (const relativePath of changes.localOnly) {
+      if (action === 'diff') {
+        console.log(color.green(`+ ${relativePath}`));
+        console.log(color.dim(`  Local only`));
+      } else if (isUpload) {
+        console.log(color.green(`+ ${relativePath}`));
+        console.log(color.dim(`  Local only → will be uploaded to Drive`));
+      } else {
+        console.log(color.red(`- ${relativePath}`));
+        console.log(color.dim(`  Local only → can be deleted (not on Drive)`));
+      }
       console.log('');
     }
 
-    for (const filename of changes.driveOnly) {
-      console.log(color.cyan(`--- /dev/null`));
-      console.log(color.cyan(`+++ ${filename} (Drive only)`));
-      console.log(color.green(`  [New Drive file - will be downloaded]`));
+    for (const relativePath of changes.driveOnly) {
+      if (action === 'diff') {
+        console.log(color.yellow(`+ ${relativePath}`));
+        console.log(color.dim(`  Drive only`));
+      } else if (isUpload) {
+        console.log(color.red(`- ${relativePath}`));
+        console.log(color.dim(`  Drive only → can be deleted from Drive (not local)`));
+      } else {
+        console.log(color.green(`+ ${relativePath}`));
+        console.log(color.dim(`  Drive only → will be downloaded to local`));
+      }
+      console.log('');
+    }
+
+    // Show orphan Drive folders
+    for (const folder of changes.orphanDriveFolders) {
+      if (action === 'diff') {
+        console.log(color.yellow(`📁 ${folder.relativePath}/`));
+        console.log(color.dim(`  Empty folder on Drive only`));
+      } else if (isUpload) {
+        console.log(color.red(`- 📁 ${folder.relativePath}/`));
+        console.log(color.dim(`  Empty folder on Drive → can be deleted`));
+      }
       console.log('');
     }
 
     // Summary
     const summaryLines = [];
     if (changes.modified.length > 0) {
-      summaryLines.push(`${color.cyan('Modified:')} ${changes.modified.join(', ')}`);
+      summaryLines.push(`${color.cyan('Modified:')} ${changes.modified.length} file(s)`);
     }
     if (changes.localOnly.length > 0) {
-      summaryLines.push(`${color.green('Local only:')} ${changes.localOnly.join(', ')}`);
+      if (action === 'diff') {
+        summaryLines.push(`${color.green('Local only:')} ${changes.localOnly.length} file(s)`);
+      } else if (isUpload) {
+        summaryLines.push(`${color.green('To upload:')} ${changes.localOnly.length} file(s)`);
+      } else {
+        summaryLines.push(`${color.red('Local only (can delete):')} ${changes.localOnly.length} file(s)`);
+      }
     }
     if (changes.driveOnly.length > 0) {
-      summaryLines.push(`${color.yellow('Drive only:')} ${changes.driveOnly.join(', ')}`);
+      if (action === 'diff') {
+        summaryLines.push(`${color.yellow('Drive only:')} ${changes.driveOnly.length} file(s)`);
+      } else if (isUpload) {
+        summaryLines.push(`${color.red('Drive only (can delete):')} ${changes.driveOnly.length} file(s)`);
+      } else {
+        summaryLines.push(`${color.green('To download:')} ${changes.driveOnly.length} file(s)`);
+      }
+    }
+    if (changes.orphanDriveFolders.length > 0 && (action === 'diff' || isUpload)) {
+      summaryLines.push(`${color.red('Empty folders on Drive:')} ${changes.orphanDriveFolders.length} folder(s)`);
     }
     note(summaryLines.join('\n'), 'Summary');
 
@@ -1063,15 +1291,18 @@ const runSyncOperation = async (syncConfig, action, projectRoot, backupPath, con
     }
 
     if (action === 'download') {
-      // Create backup first
-      const existingFiles = fs.readdirSync(envDir).filter((f) => matchPattern(f, pattern, ignore));
-      if (existingFiles.length > 0) {
+      // Create backup first (recursive)
+      const existingLocalFiles = listLocalFilesRecursive(envDir, pattern, ignore);
+      if (existingLocalFiles.length > 0) {
         const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
         const backupSubdir = path.join(backupPath, `${name}_${timestamp}`);
         fs.ensureDirSync(backupSubdir);
 
-        for (const file of existingFiles) {
-          fs.copyFileSync(path.join(envDir, file), path.join(backupSubdir, file));
+        for (const file of existingLocalFiles) {
+          const srcPath = path.join(envDir, file.relativePath);
+          const destPath = path.join(backupSubdir, file.relativePath);
+          fs.ensureDirSync(path.dirname(destPath));
+          fs.copyFileSync(srcPath, destPath);
         }
         log.info(`Backup created: ${backupSubdir}`);
       }
@@ -1081,13 +1312,19 @@ const runSyncOperation = async (syncConfig, action, projectRoot, backupPath, con
 
       let downloaded = 0;
 
-      for (const filename of changes.modified) {
-        fs.copyFileSync(path.join(tempDir, filename), path.join(envDir, filename));
+      for (const relativePath of changes.modified) {
+        const srcPath = path.join(tempDir, relativePath);
+        const destPath = path.join(envDir, relativePath);
+        fs.ensureDirSync(path.dirname(destPath));
+        fs.copyFileSync(srcPath, destPath);
         downloaded++;
       }
 
-      for (const filename of changes.driveOnly) {
-        fs.copyFileSync(path.join(tempDir, filename), path.join(envDir, filename));
+      for (const relativePath of changes.driveOnly) {
+        const srcPath = path.join(tempDir, relativePath);
+        const destPath = path.join(envDir, relativePath);
+        fs.ensureDirSync(path.dirname(destPath));
+        fs.copyFileSync(srcPath, destPath);
         downloaded++;
       }
 
@@ -1099,24 +1336,134 @@ const runSyncOperation = async (syncConfig, action, projectRoot, backupPath, con
       let uploaded = 0;
       let replaced = 0;
 
-      for (const filename of changes.modified) {
-        const driveFile = driveFiles.find((f) => f.name === filename);
+      // Build a map of relativePath -> driveFile for quick lookup
+      const driveFileMap = new Map();
+      for (const df of driveFiles) {
+        driveFileMap.set(df.relativePath, df);
+      }
+
+      for (const relativePath of changes.modified) {
+        const driveFile = driveFileMap.get(relativePath);
         if (driveFile) {
-          shell.exec(`gdrive update "${driveFile.id}" "${path.join(envDir, filename)}"`, {
-            silent: true,
-          });
+          gdrive.update(driveFile.id, path.join(envDir, relativePath));
           replaced++;
         }
       }
 
-      for (const filename of changes.localOnly) {
-        shell.exec(`gdrive upload "${path.join(envDir, filename)}" --parent "${folderId}"`, {
-          silent: true,
-        });
+      for (const relativePath of changes.localOnly) {
+        const localFilePath = path.join(envDir, relativePath);
+        const folderPath = path.dirname(relativePath);
+
+        // Find or create the parent folder on Drive
+        let parentId = folderId;
+        if (folderPath && folderPath !== '.') {
+          parentId = findOrCreateDriveFolder(folderId, folderPath);
+        }
+
+        gdrive.upload(localFilePath, { parent: parentId });
         uploaded++;
       }
 
       uploadSpinner.stop(color.green(`Replaced: ${replaced}, New: ${uploaded}`));
+
+      // Ask about deleting Drive-only files and orphan folders
+      const hasOrphanItems = changes.driveOnly.length > 0 || changes.orphanDriveFolders.length > 0;
+      if (hasOrphanItems) {
+        console.log('');
+        const totalItems = changes.driveOnly.length + changes.orphanDriveFolders.length;
+        log.warn(`${totalItems} item(s) exist on Drive but not locally:`);
+        for (const relativePath of changes.driveOnly) {
+          console.log(color.red(`  - ${relativePath}`));
+        }
+        for (const folder of changes.orphanDriveFolders) {
+          console.log(color.red(`  - 📁 ${folder.relativePath}/`));
+        }
+        console.log('');
+
+        const deleteFromDrive = await confirm({
+          message: `Delete these ${totalItems} item(s) from Drive?`,
+          initialValue: false,
+        });
+
+        if (!isCancel(deleteFromDrive) && deleteFromDrive) {
+          const deleteSpinner = spinner();
+          deleteSpinner.start('Deleting items from Drive...');
+
+          let deletedFiles = 0;
+          let deletedFolders = 0;
+
+          // Delete orphan files first
+          for (const relativePath of changes.driveOnly) {
+            const driveFile = driveFileMap.get(relativePath);
+            if (driveFile) {
+              gdrive.remove(driveFile.id);
+              deletedFiles++;
+            }
+          }
+
+          // Delete orphan folders (sort by depth, deepest first)
+          const sortedFolders = [...changes.orphanDriveFolders].sort((a, b) =>
+            b.relativePath.split('/').length - a.relativePath.split('/').length
+          );
+
+          for (const folder of sortedFolders) {
+            gdrive.remove(folder.id, { recursive: true });
+            deletedFolders++;
+          }
+
+          const resultParts = [];
+          if (deletedFiles > 0) resultParts.push(`${deletedFiles} file(s)`);
+          if (deletedFolders > 0) resultParts.push(`${deletedFolders} folder(s)`);
+          deleteSpinner.stop(color.green(`Deleted ${resultParts.join(' and ')} from Drive`));
+        }
+      }
+    }
+
+    // Ask about deleting local-only files during download
+    if (action === 'download' && changes.localOnly.length > 0) {
+      console.log('');
+      log.warn(`${changes.localOnly.length} file(s) exist locally but not on Drive:`);
+      for (const relativePath of changes.localOnly) {
+        console.log(color.red(`  - ${relativePath}`));
+      }
+      console.log('');
+      log.info(color.dim('(These files are included in the backup)'));
+
+      const deleteLocal = await confirm({
+        message: `Delete these ${changes.localOnly.length} local file(s)?`,
+        initialValue: false,
+      });
+
+      if (!isCancel(deleteLocal) && deleteLocal) {
+        const deleteSpinner = spinner();
+        deleteSpinner.start('Deleting local files...');
+
+        let deleted = 0;
+        for (const relativePath of changes.localOnly) {
+          const filePath = path.join(envDir, relativePath);
+          if (fs.existsSync(filePath)) {
+            fs.removeSync(filePath);
+            deleted++;
+          }
+        }
+
+        // Clean up empty directories
+        const cleanEmptyDirs = (dir) => {
+          if (!fs.existsSync(dir)) return;
+          const entries = fs.readdirSync(dir);
+          if (entries.length === 0 && dir !== envDir) {
+            fs.rmdirSync(dir);
+            cleanEmptyDirs(path.dirname(dir));
+          }
+        };
+
+        for (const relativePath of changes.localOnly) {
+          const dirPath = path.dirname(path.join(envDir, relativePath));
+          cleanEmptyDirs(dirPath);
+        }
+
+        deleteSpinner.stop(color.green(`Deleted ${deleted} local file(s)`));
+      }
     }
   } catch (e) {
     log.error(e.message);
@@ -1125,6 +1472,221 @@ const runSyncOperation = async (syncConfig, action, projectRoot, backupPath, con
   }
 };
 
+/**
+ * Migrate legacy syncs to Files Sync config
+ */
+const envMigrate = async () => {
+  try {
+    const { paths } = require('./config');
+    const legacyConfigPath = paths.cfgFile;
+
+    // Check if legacy config exists
+    if (!fs.existsSync(legacyConfigPath)) {
+      log.error('No legacy config found at ~/.gdrive_syncer/gdrive.config.json');
+      return;
+    }
+
+    const legacyConfig = JSON.parse(fs.readFileSync(legacyConfigPath, 'utf-8'));
+    const legacySyncs = legacyConfig.syncs || [];
+
+    if (legacySyncs.length === 0) {
+      log.warn('No syncs found in legacy config.');
+      return;
+    }
+
+    // Show legacy syncs for selection
+    const syncOptions = legacySyncs.map((s) => ({
+      value: s.name,
+      label: s.name,
+      hint: `${s.fullpath} → ${s.driveId.slice(0, 12)}...`,
+    }));
+
+    const selectedNames = await multiselect({
+      message: 'Select syncs to migrate (space to toggle, enter to confirm)',
+      options: syncOptions,
+      required: true,
+    });
+
+    if (isCancel(selectedNames)) {
+      cancel('Migration cancelled.');
+      return;
+    }
+
+    const selectedSyncs = legacySyncs.filter((s) => selectedNames.includes(s.name));
+
+    // Process each selected sync
+    for (const legacySync of selectedSyncs) {
+      console.log('');
+      note(
+        `${color.cyan('Name:')} ${legacySync.name}\n${color.cyan('Path:')} ${legacySync.fullpath}\n${color.cyan('Drive ID:')} ${legacySync.driveId}`,
+        `Migrating: ${legacySync.name}`
+      );
+
+      // Ask: Local or Global?
+      const destination = await select({
+        message: `Where to migrate "${legacySync.name}"?`,
+        options: [
+          { value: 'local', label: 'Local', hint: '.gdrive-sync.json in a project directory' },
+          { value: 'global', label: 'Global', hint: '~/.gdrive_syncer/env-sync.json' },
+        ],
+      });
+
+      if (isCancel(destination)) {
+        cancel('Migration cancelled.');
+        return;
+      }
+
+      // Get pattern
+      const pattern = await text({
+        message: 'File pattern to sync',
+        placeholder: '*',
+        defaultValue: '*',
+      });
+
+      if (isCancel(pattern)) {
+        cancel('Migration cancelled.');
+        return;
+      }
+
+      let configPath;
+      let localDir;
+      let projectRoot;
+
+      if (destination === 'local') {
+        // Ask where to create/use local config
+        const configLocation = await text({
+          message: 'Project root for local config (where .gdrive-sync.json will be)',
+          placeholder: process.cwd(),
+          defaultValue: process.cwd(),
+          validate: (v) => {
+            if (!v.trim()) return 'Path is required';
+            if (!fs.existsSync(v.trim())) return 'Directory does not exist';
+          },
+        });
+
+        if (isCancel(configLocation)) {
+          cancel('Migration cancelled.');
+          return;
+        }
+
+        projectRoot = configLocation.trim();
+        configPath = path.join(projectRoot, LOCAL_CONFIG_FILE);
+
+        // Calculate relative path
+        const relativePath = path.relative(projectRoot, legacySync.fullpath);
+
+        // Check if path goes outside project
+        if (relativePath.startsWith('..')) {
+          log.warn(`Path "${legacySync.fullpath}" is outside the project root.`);
+          log.info(`Relative path would be: ${relativePath}`);
+
+          const proceed = await confirm({
+            message: 'Use this relative path anyway? (No = switch to global)',
+            initialValue: false,
+          });
+
+          if (isCancel(proceed)) {
+            cancel('Migration cancelled.');
+            return;
+          }
+
+          if (!proceed) {
+            // Switch to global
+            log.info('Switching to global config...');
+            configPath = GLOBAL_CONFIG_FILE;
+            localDir = legacySync.fullpath; // Use absolute path for global
+            projectRoot = null;
+          } else {
+            localDir = relativePath;
+          }
+        } else {
+          localDir = relativePath;
+        }
+      } else {
+        // Global config - use absolute path
+        configPath = GLOBAL_CONFIG_FILE;
+        localDir = legacySync.fullpath;
+        projectRoot = null;
+      }
+
+      // Preview the new sync entry
+      const newSync = {
+        name: legacySync.name,
+        localDir: localDir,
+        folderId: legacySync.driveId,
+        pattern: pattern.trim(),
+      };
+
+      note(
+        `${color.cyan('Name:')} ${newSync.name}\n${color.cyan('Local Dir:')} ${newSync.localDir}\n${color.cyan('Folder ID:')} ${newSync.folderId}\n${color.cyan('Pattern:')} ${newSync.pattern}\n${color.cyan('Config:')} ${configPath}`,
+        'Preview'
+      );
+
+      const confirmMigrate = await confirm({
+        message: 'Add this sync to the config?',
+        initialValue: true,
+      });
+
+      if (isCancel(confirmMigrate) || !confirmMigrate) {
+        log.info(`Skipped "${legacySync.name}"`);
+        continue;
+      }
+
+      // Load or create config
+      let config = { ...defaultConfig };
+      if (fs.existsSync(configPath)) {
+        config = loadConfig(configPath);
+      }
+      if (!config.syncs) {
+        config.syncs = [];
+      }
+
+      // Check for duplicate name
+      const existingIndex = config.syncs.findIndex((s) => s.name === newSync.name);
+      if (existingIndex !== -1) {
+        const overwrite = await confirm({
+          message: `Sync "${newSync.name}" already exists in config. Overwrite?`,
+          initialValue: false,
+        });
+
+        if (isCancel(overwrite)) {
+          cancel('Migration cancelled.');
+          return;
+        }
+
+        if (overwrite) {
+          config.syncs[existingIndex] = newSync;
+        } else {
+          log.info(`Skipped "${legacySync.name}" (already exists)`);
+          continue;
+        }
+      } else {
+        config.syncs.push(newSync);
+      }
+
+      saveConfig(configPath, config);
+      log.success(`Migrated "${legacySync.name}" to ${configPath === GLOBAL_CONFIG_FILE ? 'global' : 'local'} config`);
+
+      // Ask if user wants to remove from legacy config
+      const removeFromLegacy = await confirm({
+        message: 'Remove from legacy config?',
+        initialValue: false,
+      });
+
+      if (!isCancel(removeFromLegacy) && removeFromLegacy) {
+        legacyConfig.syncs = legacyConfig.syncs.filter((s) => s.name !== legacySync.name);
+        fs.writeFileSync(legacyConfigPath, JSON.stringify(legacyConfig, null, 2));
+        log.success(`Removed "${legacySync.name}" from legacy config`);
+      }
+    }
+
+    console.log('');
+    log.success('Migration complete!');
+  } catch (e) {
+    log.error(e.message);
+  }
+};
+
 module.exports = {
   envInit,
   envRun,
@@ -1132,7 +1694,11 @@ module.exports = {
   envRemove,
   envRegister,
   envUnregister,
+  envMigrate,
   // Exported for testing
   globToRegex,
   matchPattern,
+  listDriveFilesRecursive,
+  listLocalFilesRecursive,
+  findOrCreateDriveFolder,
 };