gdrive-syncer 2.1.2 → 3.0.0

package/Readme.md

@@ -4,15 +4,54 @@ A command line tool to manage sync folders with Google Drive. Features two-way s
 
 ## Prerequisites
 
-Install and setup [gdrive](https://github.com/prasmussen/gdrive)
+Install the gdrive CLI. This tool supports both gdrive@2 and gdrive@3.
 
-## Login
+### Option 1: gdrive@3 (recommended)
+
+Install [gdrive@3](https://github.com/glotlabs/gdrive) via Homebrew:
+
+```bash
+brew install gdrive
+```
+
+Setup requires Google OAuth credentials.
+
+> **Before you start:** Ask your team if someone already has OAuth credentials set up for gdrive. Sharing existing credentials avoids creating duplicate Google Cloud projects and simplifies onboarding.
+
+#### Setting up OAuth credentials
+
+1. Go to [Google Cloud Console](https://console.cloud.google.com/)
+2. Create a new project or select existing
+3. Enable the Google Drive API
+4. Configure OAuth consent screen:
+   - **For organizations (Google Workspace):** Select **Internal** user type. This avoids the app review process and allows immediate use by your team.
+   - **For personal accounts:** Select **External** and add your email as a test user.
+5. Create OAuth 2.0 credentials (Desktop application)
+6. Add an account:
+   ```bash
+   gdrive account add
+   ```
+7. Enter your Client ID and Client Secret when prompted
+8. Complete the OAuth flow in your browser
+
+> **Tip:** If you're in an organization, using **Internal** OAuth consent means the app is automatically trusted for all users in your domain—no verification required.
+
+**Note:** gdrive@3 does not support `gdrive sync` commands. Use the `filesync:*` commands instead.
+
+### Option 2: gdrive@2 (legacy)
+
+[gdrive@2](https://github.com/prasmussen/gdrive) is deprecated and no longer available via Homebrew. If you have it installed, login with:
 
-After [gdrive](https://github.com/prasmussen/gdrive) is installed, login to your Google Drive account:
 ```bash
 gdrive about
 ```
 
+### Verify Installation
+
+```bash
+gdrive version
+```
+
 ## Installation
 
 ```bash
@@ -33,12 +72,15 @@ Run without arguments for interactive menu, or use direct commands.
 
 | Command | Description |
 |---------|-------------|
-| `filesync:diff [local\|global]` | Show differences between local and Drive |
-| `filesync:download [local\|global]` | Download changed files from Drive |
-| `filesync:upload [local\|global]` | Upload changed files to Drive |
+| `filesync:diff [local\|global\|registered]` | Show differences between local and Drive |
+| `filesync:download [local\|global\|registered]` | Download changed files from Drive |
+| `filesync:upload [local\|global\|registered]` | Upload changed files to Drive |
 | `filesync:init` | Create or add to `.gdrive-sync.json` config |
 | `filesync:show` | Show sync configurations |
 | `filesync:remove` | Remove a sync from config |
+| `filesync:register` | Register local config to global registry |
+| `filesync:unregister` | Remove from global registry |
+| `filesync:migrate` | Migrate legacy syncs to Files Sync format |
 
 ### Drive Operations
 
@@ -49,7 +91,9 @@ Run without arguments for interactive menu, or use direct commands.
 | `drive:mkdir` | Create a directory in Drive |
 | `drive:delete` | Delete a file/folder from Drive |
 
-### Legacy Sync (gdrive sync upload)
+### Legacy Sync (gdrive@2 only)
+
+**Note:** These commands require gdrive@2. They are not available with gdrive@3.
 
 | Command | Description |
 |---------|-------------|
@@ -180,8 +224,40 @@ Patterns support glob-style matching with the following features:
 - **Automatic backups** - Creates timestamped backups before download
 - **Two-way sync** - Upload local changes or download from Drive
 - **Sync All** - Run operations on all syncs within selected config
+- **Registered Local Configs** - Run sync on multiple projects from anywhere
 
-## Legacy Sync Configuration
+### Registered Local Configs
+
+Register local configs to a global registry, then run sync operations on multiple projects from any directory.
+
+```bash
+# Register current project's local config
+cd ~/projects/my-app
+gdrive-syncer filesync:register
+# Suggests name from directory, stores path in global registry
+
+# Later, from any directory
+cd ~/random-place
+gdrive-syncer filesync:diff
+# Shows: Local, Global, and "Registered Local Configs" option
+# Select "Registered Local Configs" → multi-select projects → run diff on all
+```
+
+**Commands:**
+- `filesync:register` - Register current local config (auto-suggests directory name)
+- `filesync:unregister` - Remove from registry
+- `filesync:show` - Shows registered configs with ✓/✗ status
+
+**Workflow:**
+1. Go to each project directory and run `filesync:register`
+2. From any terminal, run `filesync:diff` (or upload/download)
+3. Select "Registered Local Configs"
+4. Multi-select which projects to sync
+5. Operation runs on all selected projects
+
+## Legacy Sync Configuration (gdrive@2 only)
+
+> **Note:** Legacy sync requires gdrive@2. If you have gdrive@3 installed, use Files Sync (`filesync:*` commands) instead.
 
 Legacy sync uses the `gdrive sync upload` command under the hood. Configuration is stored globally at:
 
@@ -255,10 +331,30 @@ gdrive-syncer sync:upload
 gdrive-syncer sync:list
 ```
 
+## Migrating from Legacy Sync to Files Sync
+
+If you have existing legacy sync configurations (`~/.gdrive_syncer/gdrive.config.json`), you can migrate them to the new Files Sync format:
+
+```bash
+gdrive-syncer filesync:migrate
+```
+
+The migration wizard:
+1. Shows all legacy syncs and lets you select which to migrate
+2. For each sync, asks whether to save to **Local** or **Global** config
+3. For local configs, calculates the relative path from the config location
+4. Warns if the path is outside the project directory (suggests using global instead)
+5. Lets you set a file pattern (default: `*` for all files)
+6. Shows a preview before confirming
+7. Optionally removes migrated syncs from the legacy config
+
+This is not a one-time migration—you can run it multiple times to gradually migrate syncs as needed.
+
 ## Files Sync vs Legacy Sync
 
 | Feature | Files Sync | Legacy Sync |
 |---------|----------|-------------|
+| **gdrive version** | gdrive@2 and gdrive@3 | gdrive@2 only |
 | Config location | Local (`.gdrive-sync.json`) or Global (`~/.gdrive_syncer/env-sync.json`) | `~/.gdrive_syncer/gdrive.config.json` (global only) |
 | Direction | Two-way (upload & download) | One-way (upload only) |
 | File patterns | Supported (`.env.*`, `*`) | All files in folder |
@@ -286,6 +382,9 @@ gdrive-syncer filesync:diff local
 # Show differences for global config only
 gdrive-syncer filesync:diff global
 
+# Show differences for registered local configs
+gdrive-syncer filesync:diff registered
+
 # Download from Drive (with backup)
 gdrive-syncer filesync:download
 gdrive-syncer filesync:download local
@@ -294,6 +393,9 @@ gdrive-syncer filesync:download local
 gdrive-syncer filesync:upload
 gdrive-syncer filesync:upload global
 
+# Upload from all registered configs
+gdrive-syncer filesync:upload registered
+
 # Initialize config (choose Local or Global)
 gdrive-syncer filesync:init
 

package/package.json

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

package/run.js

@@ -5,15 +5,15 @@ const color = require('picocolors');
 const { cfgAdd, cfgRm, cfgShow } = require('./src/cfgManager');
 const { runSync } = require('./src/sync');
 const { runList, runSearch, runDelete, runMkdir, runListSync } = require('./src/list');
-const { envInit, envRun, envShow, envRemove, envDiff, envDownload, envUpload } = require('./src/envSync');
+const { envInit, envRun, envShow, envRemove, envRegister, envUnregister, envMigrate } = require('./src/envSync');
 
 const [, , ...args] = process.argv;
 const [firstArg] = args;
 
-// Get config type from args (local/global)
+// Get config type from args (local/global/registered)
 const getConfigType = () => {
   const arg = args[1]?.toLowerCase();
-  if (arg === 'local' || arg === 'global') return arg;
+  if (arg === 'local' || arg === 'global' || arg === 'registered') return arg;
   return null;
 };
 
@@ -27,6 +27,9 @@ const commands = {
   'filesync:init': { handler: envInit, desc: 'Create/add sync config' },
   'filesync:show': { handler: envShow, desc: 'Show sync configurations' },
   'filesync:remove': { handler: envRemove, desc: 'Remove sync config' },
+  'filesync:register': { handler: envRegister, desc: 'Register local config to global' },
+  'filesync:unregister': { handler: envUnregister, desc: 'Unregister local config' },
+  'filesync:migrate': { handler: envMigrate, desc: 'Migrate legacy syncs to Files Sync' },
 
   // Drive Operations
   'drive:search': { handler: runSearch, desc: 'Search files in Drive' },
@@ -47,12 +50,15 @@ const showHelp = () => {
   const lines = [
     `${color.bold('Files Sync')} ${color.dim('(two-way sync with .gdrive-sync.json)')}`,
     `  filesync                  ${color.dim('Interactive sync menu')}`,
-    `  filesync:diff [local|global]   ${color.dim('Show differences')}`,
-    `  filesync:download [local|global] ${color.dim('Download from Drive')}`,
-    `  filesync:upload [local|global]   ${color.dim('Upload to Drive')}`,
+    `  filesync:diff [local|global|registered]   ${color.dim('Show differences')}`,
+    `  filesync:download [local|global|registered] ${color.dim('Download from Drive')}`,
+    `  filesync:upload [local|global|registered]   ${color.dim('Upload to Drive')}`,
     `  filesync:init             ${color.dim('Create/add sync config')}`,
     `  filesync:show             ${color.dim('Show configurations')}`,
     `  filesync:remove           ${color.dim('Remove sync config')}`,
+    `  filesync:register         ${color.dim('Register local config to global')}`,
+    `  filesync:unregister       ${color.dim('Unregister local config')}`,
+    `  filesync:migrate          ${color.dim('Migrate legacy syncs to Files Sync')}`,
     ``,
     `${color.bold('Drive Operations')}`,
     `  drive:search  ${color.dim('Search files')}`,
@@ -130,6 +136,9 @@ const showHelp = () => {
           { value: 'filesync:init', label: 'Init', hint: 'Create/add to .gdrive-sync.json' },
           { value: 'filesync:show', label: 'Show', hint: 'Show sync configurations' },
           { value: 'filesync:remove', label: 'Remove', hint: 'Remove a sync from config' },
+          { value: 'filesync:register', label: 'Register', hint: 'Register local config to global' },
+          { value: 'filesync:unregister', label: 'Unregister', hint: 'Unregister local config' },
+          { value: 'filesync:migrate', label: 'Migrate', hint: 'Migrate legacy syncs to Files Sync' },
         ],
       });
     } else if (category === 'drive') {
@@ -152,6 +161,7 @@ const showHelp = () => {
           { value: 'sync:show', label: 'Show Config', hint: 'View sync configurations' },
           { value: 'sync:add', label: 'Add Config', hint: 'Add a new sync configuration' },
           { value: 'sync:remove', label: 'Remove Config', hint: 'Remove a sync configuration' },
+          { value: 'filesync:migrate', label: 'Migrate to Files Sync', hint: 'Migrate to new format' },
         ],
       });
     }

package/src/envSync.js

@@ -2,9 +2,10 @@
 
 const shell = require('shelljs');
 const fs = require('fs-extra');
+const gdrive = require('./gdriveCmd');
 const path = require('path');
 const os = require('os');
-const { select, text, isCancel, cancel, spinner, confirm, note, log } = require('@clack/prompts');
+const { select, multiselect, text, isCancel, cancel, spinner, confirm, note, log } = require('@clack/prompts');
 const color = require('picocolors');
 
 // Config file names
@@ -18,6 +19,7 @@ const GLOBAL_CONFIG_FILE = path.join(GLOBAL_CONFIG_DIR, 'env-sync.json');
 const defaultConfig = {
   syncs: [],
   backupDir: 'gdrive-backups',
+  localRefs: [], // Registered local config references
 };
 
 /**
@@ -359,6 +361,120 @@ const envRemove = async () => {
   }
 };
 
+/**
+ * Register current local config to global registry
+ */
+const envRegister = async () => {
+  try {
+    const localConfig = findLocalConfig();
+
+    if (!localConfig) {
+      log.error('No local config found in current directory tree.');
+      log.info('Run "filesync:init" to create one first.');
+      return;
+    }
+
+    // Ensure global config exists
+    fs.ensureDirSync(GLOBAL_CONFIG_DIR);
+    let globalConfig = { ...defaultConfig };
+    if (fs.existsSync(GLOBAL_CONFIG_FILE)) {
+      globalConfig = loadConfig(GLOBAL_CONFIG_FILE);
+    }
+    if (!globalConfig.localRefs) {
+      globalConfig.localRefs = [];
+    }
+
+    // Check if already registered
+    const existing = globalConfig.localRefs.find((r) => r.configPath === localConfig.configPath);
+    if (existing) {
+      log.warn(`Already registered as "${existing.name}"`);
+      log.info(`Path: ${localConfig.configPath}`);
+      return;
+    }
+
+    // Auto-suggest name from directory
+    const dirName = path.basename(localConfig.projectRoot);
+    const name = await text({
+      message: 'Name for this registered config',
+      placeholder: dirName,
+      defaultValue: dirName,
+      validate: (v) => {
+        if (!v.trim()) return 'Name is required';
+        if (globalConfig.localRefs.find((r) => r.name === v.trim())) return 'Name already exists';
+      },
+    });
+
+    if (isCancel(name)) {
+      cancel('Registration cancelled.');
+      return;
+    }
+
+    globalConfig.localRefs.push({
+      name: name.trim(),
+      configPath: localConfig.configPath,
+    });
+
+    saveConfig(GLOBAL_CONFIG_FILE, globalConfig);
+
+    log.success(`Registered "${name}" → ${localConfig.configPath}`);
+  } catch (e) {
+    log.error(e.message);
+  }
+};
+
+/**
+ * Unregister a local config from global registry
+ */
+const envUnregister = async () => {
+  try {
+    if (!fs.existsSync(GLOBAL_CONFIG_FILE)) {
+      log.error('No global config found.');
+      return;
+    }
+
+    const globalConfig = loadConfig(GLOBAL_CONFIG_FILE);
+    const refs = globalConfig.localRefs || [];
+
+    if (refs.length === 0) {
+      log.warn('No registered local configs.');
+      return;
+    }
+
+    const options = refs.map((r) => ({
+      value: r.name,
+      label: r.name,
+      hint: r.configPath,
+    }));
+
+    const picked = await select({
+      message: 'Select config to unregister',
+      options,
+    });
+
+    if (isCancel(picked)) {
+      cancel('Cancelled.');
+      return;
+    }
+
+    const shouldRemove = await confirm({
+      message: `Unregister "${picked}"?`,
+      initialValue: false,
+    });
+
+    if (isCancel(shouldRemove) || !shouldRemove) {
+      cancel('Cancelled.');
+      return;
+    }
+
+    globalConfig.localRefs = refs.filter((r) => r.name !== picked);
+    saveConfig(GLOBAL_CONFIG_FILE, globalConfig);
+
+    log.success(`Unregistered "${picked}"`);
+  } catch (e) {
+    log.error(e.message);
+  }
+};
+
 /**
  * Show current config
  */
@@ -427,6 +543,23 @@ const envShow = async () => {
     if (!globalConfig) {
       log.info(color.dim('No global config found.'));
     }
+
+    // Show registered local configs
+    if (globalConfig) {
+      const gc = loadConfig(globalConfig.configPath);
+      const refs = gc.localRefs || [];
+      if (refs.length > 0) {
+        console.log(''); // spacing
+        const lines = refs
+          .map((r) => {
+            const exists = fs.existsSync(r.configPath);
+            const status = exists ? color.green('✓') : color.red('✗ missing');
+            return `${color.cyan(r.name.padEnd(20))} ${status} ${color.dim(r.configPath)}`;
+          })
+          .join('\n');
+        note(lines, `Registered Local Configs (${refs.length})`);
+      }
+    }
   } catch (e) {
     log.error(e.message);
   }
@@ -581,12 +714,19 @@ const envRun = async (presetAction, presetConfigType) => {
       }));
     }
 
-    if (localSyncs.length === 0 && globalSyncs.length === 0) {
+    // Load registered local configs
+    let registeredRefs = [];
+    if (globalConfig) {
+      const gc = loadConfig(globalConfig.configPath);
+      registeredRefs = (gc.localRefs || []).filter((r) => fs.existsSync(r.configPath));
+    }
+
+    if (localSyncs.length === 0 && globalSyncs.length === 0 && registeredRefs.length === 0) {
       log.warn('No syncs configured. Run "env:init" to add one.');
       return;
     }
 
-    // First: pick Local or Global (if both exist)
+    // First: pick Local, Global, or Registered
     let selectedSyncs = [];
     let configType;
 
@@ -600,35 +740,96 @@ 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 if (localSyncs.length > 0 && globalSyncs.length > 0) {
-      configType = await select({
-        message: 'Which config?',
-        options: [
-          {
-            value: 'local',
-            label: 'Local',
-            hint: `${localSyncs.length} sync(s) in .gdrive-sync.json`,
-          },
-          {
-            value: 'global',
-            label: 'Global',
-            hint: `${globalSyncs.length} sync(s) in ~/.gdrive_syncer/`,
-          },
-        ],
+    } else {
+      // Build options dynamically
+      const configOptions = [];
+      if (localSyncs.length > 0) {
+        configOptions.push({
+          value: 'local',
+          label: 'Local',
+          hint: `${localSyncs.length} sync(s) in .gdrive-sync.json`,
+        });
+      }
+      if (globalSyncs.length > 0) {
+        configOptions.push({
+          value: 'global',
+          label: 'Global',
+          hint: `${globalSyncs.length} sync(s) in ~/.gdrive_syncer/`,
+        });
+      }
+      if (registeredRefs.length > 0) {
+        configOptions.push({
+          value: 'registered',
+          label: 'Registered Local Configs',
+          hint: `${registeredRefs.length} registered project(s)`,
+        });
+      }
+
+      if (configOptions.length === 1) {
+        configType = configOptions[0].value;
+        log.info(`Using ${configType} config`);
+      } else {
+        configType = await select({
+          message: 'Which config?',
+          options: configOptions,
+        });
+
+        if (isCancel(configType)) {
+          cancel('Operation cancelled.');
+          return;
+        }
+      }
+    }
+
+    // Handle registered configs with multi-select
+    if (configType === 'registered') {
+      const refOptions = registeredRefs.map((r) => ({
+        value: r.configPath,
+        label: r.name,
+        hint: path.dirname(r.configPath),
+      }));
+
+      const selectedRefs = await multiselect({
+        message: 'Select configs to run (space to toggle, enter to confirm)',
+        options: refOptions,
+        required: true,
       });
 
-      if (isCancel(configType)) {
+      if (isCancel(selectedRefs)) {
         cancel('Operation cancelled.');
         return;
       }
-    } else if (localSyncs.length > 0) {
-      configType = 'local';
-      log.info(`Using local config`);
-    } else {
-      configType = 'global';
-      log.info(`Using global config`);
+
+      // Load syncs from each selected registered config
+      for (const refPath of selectedRefs) {
+        const ref = registeredRefs.find((r) => r.configPath === refPath);
+        const refConfig = loadConfig(refPath);
+        const refProjectRoot = path.dirname(refPath);
+        const refSyncs = (refConfig.syncs || []).map((s) => ({
+          ...s,
+          _configType: 'registered',
+          _configPath: refPath,
+          _projectRoot: refProjectRoot,
+          _globalBackupDir: refConfig.backupDir,
+          _refName: ref.name,
+        }));
+        selectedSyncs.push(...refSyncs);
+      }
+
+      // Process all selected syncs
+      for (const syncConfig of selectedSyncs) {
+        const projectRoot = syncConfig._projectRoot;
+        const globalBackupDir = syncConfig._globalBackupDir || 'gdrive-backups';
+        const backupPath = path.join(projectRoot, syncConfig.backupDir || globalBackupDir);
+        await runSyncOperation(syncConfig, action, projectRoot, backupPath, 'registered');
+      }
+      return;
     }
 
     const syncs = configType === 'local' ? localSyncs : globalSyncs;
@@ -711,8 +912,9 @@ const runSyncOperation = async (syncConfig, action, projectRoot, backupPath, con
     const s = spinner();
     s.start('Fetching files from Google Drive...');
 
-    const listResult = shell.exec(`gdrive list -q "'${folderId}' in parents" --no-header`, {
-      silent: true,
+    const listResult = gdrive.list({
+      query: `'${folderId}' in parents`,
+      noHeader: true,
     });
 
     if (listResult.code !== 0) {
@@ -725,24 +927,18 @@ const runSyncOperation = async (syncConfig, action, projectRoot, backupPath, con
     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 });
-          }
+      const parsed = gdrive.parseListOutput(stdout);
+      for (const file of parsed) {
+        if (file.id && file.name && matchPattern(file.name, pattern, ignore)) {
+          driveFiles.push({ id: file.id, name: file.name });
         }
-      });
+      }
     }
 
     // Download Drive files to temp for comparison
     s.message('Downloading Drive files for comparison...');
     for (const file of driveFiles) {
-      shell.exec(`gdrive download "${file.id}" --path "${tempDir}" --force`, { silent: true });
+      gdrive.download(file.id, { destination: tempDir, overwrite: true });
     }
     s.stop(color.green(`Found ${driveFiles.length} matching file(s) on Drive`));
 
@@ -906,17 +1102,13 @@ const runSyncOperation = async (syncConfig, action, projectRoot, backupPath, con
       for (const filename of changes.modified) {
         const driveFile = driveFiles.find((f) => f.name === filename);
         if (driveFile) {
-          shell.exec(`gdrive update "${driveFile.id}" "${path.join(envDir, filename)}"`, {
-            silent: true,
-          });
+          gdrive.update(driveFile.id, path.join(envDir, filename));
           replaced++;
         }
       }
 
       for (const filename of changes.localOnly) {
-        shell.exec(`gdrive upload "${path.join(envDir, filename)}" --parent "${folderId}"`, {
-          silent: true,
-        });
+        gdrive.upload(path.join(envDir, filename), { parent: folderId });
         uploaded++;
       }
 
@@ -929,11 +1121,229 @@ 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,
   envShow,
   envRemove,
+  envRegister,
+  envUnregister,
+  envMigrate,
   // Exported for testing
   globToRegex,
   matchPattern,

package/src/gdriveCmd.js

@@ -0,0 +1,301 @@
+#!/usr/bin/env node
+
+const shell = require('shelljs');
+
+let cachedVersion = null;
+
+/**
+ * Detect gdrive version (2 or 3)
+ * gdrive@2: "gdrive v2.1.1"
+ * gdrive@3: "gdrive 3.9.1 ..."
+ */
+const detectVersion = () => {
+  if (cachedVersion !== null) {
+    return cachedVersion;
+  }
+
+  const result = shell.exec('gdrive version', { silent: true });
+  if (result.code !== 0) {
+    // Try gdrive about as fallback (gdrive@2)
+    const aboutResult = shell.exec('gdrive about', { silent: true });
+    if (aboutResult.code === 0) {
+      cachedVersion = 2;
+      return cachedVersion;
+    }
+    throw new Error('gdrive not found. Please install gdrive CLI.');
+  }
+
+  const output = result.stdout.toLowerCase();
+  // gdrive@3 outputs: "gdrive 3.x.x ..."
+  // gdrive@2 outputs: "gdrive v2.x.x"
+  if (output.includes('v2.') || output.includes('gdrive 2.')) {
+    cachedVersion = 2;
+  } else if (output.match(/gdrive\s+3\./)) {
+    cachedVersion = 3;
+  } else {
+    // Default to 3 for newer versions
+    cachedVersion = 3;
+  }
+
+  return cachedVersion;
+};
+
+/**
+ * Get the detected gdrive version
+ */
+const getVersion = () => detectVersion();
+
+/**
+ * Check if sync commands are available (only in gdrive@2)
+ */
+const hasSyncSupport = () => detectVersion() === 2;
+
+/**
+ * List files in Google Drive
+ * @param {Object} options
+ * @param {string} options.query - Search query
+ * @param {number} options.max - Max results
+ * @param {boolean} options.noHeader - Skip header row
+ * @param {boolean} options.absolute - Show absolute paths (v2 only)
+ * @param {string} options.parent - Parent folder ID (v3 only, alternative to query)
+ */
+const list = (options = {}) => {
+  const version = detectVersion();
+  const { query, max = 30, noHeader = false, absolute = false, parent } = options;
+
+  let cmd;
+  if (version === 2) {
+    cmd = 'gdrive list';
+    if (max) cmd += ` --max ${max}`;
+    if (query) cmd += ` --query "${query}"`;
+    if (noHeader) cmd += ' --no-header';
+    if (absolute) cmd += ' --absolute';
+  } else {
+    cmd = 'gdrive files list';
+    if (max) cmd += ` --max ${max}`;
+    if (parent) {
+      cmd += ` --parent ${parent}`;
+    } else if (query) {
+      cmd += ` --query "${query}"`;
+    }
+    if (noHeader) cmd += ' --skip-header';
+    // Note: --absolute not available in v3
+  }
+
+  return shell.exec(cmd, { silent: true });
+};
+
+/**
+ * Download a file from Google Drive
+ * @param {string} fileId - File ID to download
+ * @param {Object} options
+ * @param {string} options.destination - Download destination path
+ * @param {boolean} options.overwrite - Overwrite existing files
+ * @param {boolean} options.recursive - Download directory recursively
+ */
+const download = (fileId, options = {}) => {
+  const version = detectVersion();
+  const { destination, overwrite = false, recursive = false } = options;
+
+  let cmd;
+  if (version === 2) {
+    cmd = `gdrive download "${fileId}"`;
+    if (destination) cmd += ` --path "${destination}"`;
+    if (overwrite) cmd += ' --force';
+    if (recursive) cmd += ' -r';
+  } else {
+    cmd = `gdrive files download "${fileId}"`;
+    if (destination) cmd += ` --destination "${destination}"`;
+    if (overwrite) cmd += ' --overwrite';
+    if (recursive) cmd += ' --recursive';
+  }
+
+  return shell.exec(cmd, { silent: true });
+};
+
+/**
+ * Upload a file to Google Drive
+ * @param {string} filePath - Local file path to upload
+ * @param {Object} options
+ * @param {string} options.parent - Parent folder ID
+ * @param {boolean} options.recursive - Upload directory recursively
+ */
+const upload = (filePath, options = {}) => {
+  const version = detectVersion();
+  const { parent, recursive = false } = options;
+
+  let cmd;
+  if (version === 2) {
+    cmd = `gdrive upload "${filePath}"`;
+    if (parent) cmd += ` --parent "${parent}"`;
+    if (recursive) cmd += ' -r';
+  } else {
+    cmd = `gdrive files upload "${filePath}"`;
+    if (parent) cmd += ` --parent "${parent}"`;
+    if (recursive) cmd += ' --recursive';
+  }
+
+  return shell.exec(cmd, { silent: true });
+};
+
+/**
+ * Update an existing file on Google Drive
+ * @param {string} fileId - File ID to update
+ * @param {string} filePath - Local file path with new content
+ */
+const update = (fileId, filePath) => {
+  const version = detectVersion();
+
+  let cmd;
+  if (version === 2) {
+    cmd = `gdrive update "${fileId}" "${filePath}"`;
+  } else {
+    cmd = `gdrive files update "${fileId}" "${filePath}"`;
+  }
+
+  return shell.exec(cmd, { silent: true });
+};
+
+/**
+ * Create a directory on Google Drive
+ * @param {string} name - Directory name
+ * @param {Object} options
+ * @param {string} options.parent - Parent folder ID
+ */
+const mkdir = (name, options = {}) => {
+  const version = detectVersion();
+  const { parent } = options;
+
+  let cmd;
+  if (version === 2) {
+    if (parent) {
+      cmd = `gdrive mkdir -p ${parent} "${name}"`;
+    } else {
+      cmd = `gdrive mkdir "${name}"`;
+    }
+  } else {
+    cmd = `gdrive files mkdir "${name}"`;
+    if (parent) cmd += ` --parent ${parent}`;
+  }
+
+  return shell.exec(cmd, { silent: true });
+};
+
+/**
+ * Delete a file or directory on Google Drive
+ * @param {string} fileId - File/folder ID to delete
+ * @param {Object} options
+ * @param {boolean} options.recursive - Delete directory recursively
+ */
+const remove = (fileId, options = {}) => {
+  const version = detectVersion();
+  const { recursive = false } = options;
+
+  let cmd;
+  if (version === 2) {
+    cmd = `gdrive delete ${fileId}`;
+    if (recursive) cmd += ' -r';
+  } else {
+    cmd = `gdrive files delete ${fileId}`;
+    if (recursive) cmd += ' --recursive';
+  }
+
+  return shell.exec(cmd, { silent: true });
+};
+
+/**
+ * Sync upload (gdrive@2 only) - uploads local to drive
+ * @param {string} localPath - Local directory path
+ * @param {string} driveId - Drive folder ID
+ * @param {Object} options
+ * @param {boolean} options.dryRun - Preview changes without applying
+ * @param {boolean} options.keepLocal - Don't delete local files
+ * @param {boolean} options.deleteExtraneous - Delete files on drive not in local
+ */
+const syncUpload = (localPath, driveId, options = {}) => {
+  const version = detectVersion();
+  const { dryRun = false, keepLocal = true, deleteExtraneous = false } = options;
+
+  if (version !== 2) {
+    return {
+      code: 1,
+      stdout: '',
+      stderr: 'gdrive sync commands are not available in gdrive@3. Use envSync instead.',
+    };
+  }
+
+  let cmd = `gdrive sync upload`;
+  if (dryRun) cmd += ' --dry-run';
+  if (keepLocal) cmd += ' --keep-local';
+  if (deleteExtraneous) cmd += ' --delete-extraneous';
+  cmd += ` "${localPath}" ${driveId}`;
+
+  return shell.exec(cmd, { silent: true });
+};
+
+/**
+ * List sync tasks (gdrive@2 only)
+ */
+const syncList = () => {
+  const version = detectVersion();
+
+  if (version !== 2) {
+    return {
+      code: 1,
+      stdout: '',
+      stderr: 'gdrive sync commands are not available in gdrive@3.',
+    };
+  }
+
+  return shell.exec('gdrive sync list', { silent: true });
+};
+
+/**
+ * Parse list output into structured data
+ * Works with both v2 and v3 output formats
+ * @param {string} stdout - Raw stdout from list command
+ * @returns {Array<{id: string, name: string, type: string, size: string, date: string}>}
+ */
+const parseListOutput = (stdout) => {
+  const lines = stdout.trim().split('\n').filter((line) => line.trim());
+
+  if (lines.length === 0) return [];
+
+  // Both v2 and v3 use space-padded columns for alignment
+  // Split by 2+ whitespace characters to handle this
+  const separator = /\s{2,}/;
+
+  return lines.map((line) => {
+    const parts = line.trim().split(separator);
+    return {
+      id: parts[0] || '',
+      name: parts[1] || '',
+      type: parts[2] || '',
+      size: parts[3] || '',
+      date: parts[4] || '',
+    };
+  });
+};
+
+/**
+ * Clear the cached version (useful for testing)
+ */
+const clearCache = () => {
+  cachedVersion = null;
+};
+
+module.exports = {
+  detectVersion,
+  getVersion,
+  hasSyncSupport,
+  list,
+  download,
+  upload,
+  update,
+  mkdir,
+  remove,
+  syncUpload,
+  syncList,
+  parseListOutput,
+  clearCache,
+};

package/src/list.js

@@ -3,6 +3,7 @@
 const shell = require('shelljs');
 const { text, isCancel, cancel, spinner, confirm, log } = require('@clack/prompts');
 const color = require('picocolors');
+const gdrive = require('./gdriveCmd');
 
 const runSearch = async () => {
   try {
@@ -38,10 +39,11 @@ const runSearch = async () => {
     const s = spinner();
     s.start(`Searching for "${search}"...`);
 
-    const result = shell.exec(
-      `gdrive list --max ${maxResults} --query "name contains '${search.trim()}'" --absolute`,
-      { silent: true }
-    );
+    const result = gdrive.list({
+      max: maxResults,
+      query: `name contains '${search.trim()}'`,
+      absolute: true, // Only works with gdrive@2
+    });
 
     s.stop(color.green('Search complete!'));
     console.log(result.stdout);
@@ -88,10 +90,11 @@ const runList = async () => {
     const s = spinner();
     s.start('Fetching folder contents...');
 
-    const result = shell.exec(
-      `gdrive list --max ${maxResults} --query "parents in '${driveId.trim()}'" --absolute`,
-      { silent: true }
-    );
+    const result = gdrive.list({
+      max: maxResults,
+      query: `parents in '${driveId.trim()}'`,
+      absolute: true, // Only works with gdrive@2
+    });
 
     s.stop(color.green('Done!'));
     console.log(result.stdout);
@@ -106,10 +109,16 @@ const runList = async () => {
 
 const runListSync = async () => {
   try {
+    if (!gdrive.hasSyncSupport()) {
+      log.warn('gdrive sync commands are not available in gdrive@3.');
+      log.info('Use "gdrive-syncer env" for file sync functionality instead.');
+      return;
+    }
+
     const s = spinner();
     s.start('Fetching sync list...');
 
-    const result = shell.exec('gdrive sync list', { silent: true });
+    const result = gdrive.syncList();
 
     s.stop(color.green('Done!'));
     console.log(result.stdout);
@@ -153,7 +162,7 @@ const runMkdir = async () => {
     const s = spinner();
     s.start(`Creating folder "${folder}"...`);
 
-    const result = shell.exec(`gdrive mkdir -p ${parentId.trim()} ${folder.trim()}`, { silent: true });
+    const result = gdrive.mkdir(folder.trim(), { parent: parentId.trim() });
 
     s.stop(color.green(`Folder "${folder}" created!`));
     console.log(result.stdout);
@@ -194,7 +203,7 @@ const runDelete = async () => {
     const s = spinner();
     s.start('Deleting...');
 
-    const result = shell.exec(`gdrive delete -r ${driveId.trim()}`, { silent: true });
+    const result = gdrive.remove(driveId.trim(), { recursive: true });
 
     s.stop(color.green('Deleted successfully!'));
     console.log(result.stdout);

package/src/sync.js

@@ -6,12 +6,10 @@ const os = require('os');
 const { select, isCancel, cancel, spinner, note, log, confirm } = require('@clack/prompts');
 const color = require('picocolors');
 const { getCfgFile } = require('./helpers');
+const gdrive = require('./gdriveCmd');
 
 const homedir = os.homedir();
 
-const getQuery = ({ dry, pth, dId }) =>
-  `gdrive sync upload ${dry ? '--dry-run' : ''} --keep-local --delete-extraneous ${pth} ${dId}`;
-
 const syncOne = (cfg, dryRun) => {
   const fullpath = cfg.fullpath;
   const driveId = cfg.driveId;
@@ -29,7 +27,14 @@ const syncOne = (cfg, dryRun) => {
     return;
   }
 
-  shell.exec(getQuery({ dry: !!dryRun, dId: driveId, pth: fullpath }));
+  const result = gdrive.syncUpload(fullpath, driveId, {
+    dryRun: !!dryRun,
+    keepLocal: true,
+    deleteExtraneous: true,
+  });
+
+  if (result.stdout) console.log(result.stdout);
+  if (result.stderr) log.error(result.stderr);
 };
 
 const syncAll = (syncs, dryRun) => {
@@ -44,6 +49,16 @@ const syncAll = (syncs, dryRun) => {
 
 const runSync = async (dryRun) => {
   try {
+    // Check if sync commands are available (gdrive@2 only)
+    if (!gdrive.hasSyncSupport()) {
+      log.error('gdrive sync commands are not available in gdrive@3.');
+      log.info('');
+      log.info('Options:');
+      log.info('  1. Use "gdrive-syncer env" for file sync functionality (recommended)');
+      log.info('  2. Install gdrive@2 if you need legacy sync support');
+      return;
+    }
+
     note(
       dryRun ? color.yellow('Running Dry Run') : color.green('Actual Sync'),
       dryRun ? 'Preview Mode' : 'Upload Mode'

package/gdrive.config.json

@@ -1,16 +0,0 @@
-{
-  "syncs": [
-    {
-      "localpath": "project_envs/php-sayhey",
-      "driveId": "1jN1oOZKETwQL4FyoEoCCLlqBwLmYJLRd"
-    },
-    {
-      "localpath": "project_envs/sayhey",
-      "driveId": "1movI2Vgu2OMFRUl_aWvJqeQ65c_LZJG8"
-    },
-    {
-      "localpath": "project_envs/pipeline-test",
-      "driveId": "19rP3yIsLNQ2V4ViahgGyK-BJu60W6rEp"
-    }
-  ]
-}