gdrive-syncer 2.1.1 → 2.2.0

package/Readme.md

@@ -39,6 +39,8 @@ Run without arguments for interactive menu, or use direct commands.
 | `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 |
 
 ### Drive Operations
 
@@ -132,10 +134,44 @@ Global config at `~/.gdrive_syncer/env-sync.json` uses absolute paths:
 | `name` | Unique name for the sync |
 | `folderId` | Google Drive folder ID |
 | `localDir` | Local directory path (relative for local config, absolute for global) |
-| `pattern` | File pattern to sync (e.g., `.env.*`, `*`, `*.json`) |
+| `pattern` | File pattern to sync (see [Pattern Syntax](#pattern-syntax)) |
+| `ignore` | Optional pattern to exclude files (see [Pattern Syntax](#pattern-syntax)) |
 | `backupDir` (per-sync) | Override backup directory for this sync only |
 | `backupDir` (root) | Default backup directory (local: `gdrive-backups`, global: `~/gdrive-backups`) |
 
+### Pattern Syntax
+
+Patterns support glob-style matching with the following features:
+
+| Pattern | Description | Example |
+|---------|-------------|---------|
+| `*` | Matches any characters | `.env.*` matches `.env.development`, `.env.production` |
+| `?` | Matches single character | `file?.txt` matches `file1.txt`, `fileA.txt` |
+| `[abc]` | Matches specific characters | `file[123].txt` matches `file1.txt`, `file2.txt` |
+| `[a-z]` | Matches character range | `[0-9]` matches any digit |
+| `[!abc]` | Negated character class | `[!.]` matches any non-dot character |
+| `regex:` | Raw regex (advanced) | `regex:\.env\.[^.]+$` for precise matching |
+
+#### Examples
+
+```json
+// Match all .env files
+"pattern": ".env.*"
+
+// Match .env files but exclude .template files
+"pattern": ".env.*",
+"ignore": "*.template"
+
+// Match .env files without additional extensions (no dots after env name)
+"pattern": ".env.[!.]*"
+
+// Match using raw regex (excludes .env.xx.template)
+"pattern": "regex:\\.env\\.[^.]+$"
+
+// Match specific file types
+"pattern": "*.[jt]s"   // matches .js and .ts files
+```
+
 ### Features
 
 - **Multiple sync folders** - Configure multiple sync pairs in one config
@@ -146,6 +182,36 @@ Global config at `~/.gdrive_syncer/env-sync.json` uses absolute paths:
 - **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
+
+### 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
 

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "gdrive-syncer",
-  "version": "2.1.1",
+  "version": "2.2.0",
   "description": "Google Drive Syncer",
   "main": "./index.js",
   "bin": "./run.js",
   "scripts": {
-    "test": "echo \"No test specified\""
+    "test": "jest"
   },
   "keywords": [
     "Google",
@@ -25,7 +25,9 @@
     "picocolors": "^1.1.1",
     "shelljs": "^0.8.5"
   },
-  "devDependencies": {},
+  "devDependencies": {
+    "jest": "^30.2.0"
+  },
   "np": {
     "yarn": false,
     "2fa": false

package/run.js

@@ -5,7 +5,7 @@ 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 } = require('./src/envSync');
 
 const [, , ...args] = process.argv;
 const [firstArg] = args;
@@ -27,6 +27,8 @@ 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' },
 
   // Drive Operations
   'drive:search': { handler: runSearch, desc: 'Search files in Drive' },
@@ -53,6 +55,8 @@ const showHelp = () => {
     `  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')}`,
     ``,
     `${color.bold('Drive Operations')}`,
     `  drive:search  ${color.dim('Search files')}`,
@@ -130,6 +134,8 @@ 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' },
         ],
       });
     } else if (category === 'drive') {

package/src/envSync.js

@@ -4,7 +4,7 @@ const shell = require('shelljs');
 const fs = require('fs-extra');
 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 +18,7 @@ const GLOBAL_CONFIG_FILE = path.join(GLOBAL_CONFIG_DIR, 'env-sync.json');
 const defaultConfig = {
   syncs: [],
   backupDir: 'gdrive-backups',
+  localRefs: [], // Registered local config references
 };
 
 /**
@@ -184,7 +185,7 @@ const envInit = async () => {
     }
 
     const pattern = await text({
-      message: 'File pattern to sync (e.g., ".env.*", "*")',
+      message: 'File pattern to sync (* any, ? single char, [abc] class, [!x] negated, regex:... raw)',
       placeholder: '.env.*',
       defaultValue: '.env.*',
     });
@@ -194,6 +195,16 @@ const envInit = async () => {
       return;
     }
 
+    const ignore = await text({
+      message: 'Ignore pattern (leave empty for none)',
+      placeholder: 'e.g., *.template, *.backup',
+    });
+
+    if (isCancel(ignore)) {
+      cancel('Init cancelled.');
+      return;
+    }
+
     // For global config, ask for absolute backup path
     let syncBackupDir;
     if (saveLocation === 'global') {
@@ -222,6 +233,11 @@ const envInit = async () => {
       pattern: pattern.trim(),
     };
 
+    // Only add ignore if specified
+    if (ignore && ignore.trim()) {
+      newSync.ignore = ignore.trim();
+    }
+
     // Only add backupDir if specified
     if (syncBackupDir && syncBackupDir.trim()) {
       newSync.backupDir = cleanPath(syncBackupDir);
@@ -231,8 +247,11 @@ const envInit = async () => {
     saveConfig(configPath, config);
 
     log.success(`Config saved: ${configPath}`);
+    const ignoreInfo = ignore && ignore.trim() ? `\n${color.cyan('Ignore:')} ${ignore}` : '';
     note(
-      `${color.cyan('Name:')} ${name}\n${color.cyan('Folder ID:')} ${folderId}\n${color.cyan('Local Dir:')} ${destDir}\n${color.cyan('Pattern:')} ${pattern}`,
+      `${color.cyan('Name:')} ${name}\n${color.cyan('Folder ID:')} ${folderId}\n${color.cyan(
+        'Local Dir:'
+      )} ${destDir}\n${color.cyan('Pattern:')} ${pattern}${ignoreInfo}`,
       'New Sync Added'
     );
   } catch (e) {
@@ -278,8 +297,16 @@ const envRemove = async () => {
       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/` },
+          {
+            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/`,
+          },
         ],
       });
 
@@ -333,6 +360,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
  */
@@ -353,7 +494,12 @@ const envShow = async () => {
         const lines = config.syncs
           .map((s) => {
             const backupInfo = s.backupDir ? color.yellow(` [backup: ${s.backupDir}]`) : '';
-            return `${color.cyan(s.name.padEnd(15))} ${color.dim('|')} ${s.localDir.padEnd(20)} ${color.dim('↔')} ${s.folderId.slice(0, 12)}... ${color.dim(`(${s.pattern})`)}${backupInfo}`;
+            const ignoreInfo = s.ignore ? color.red(` [ignore: ${s.ignore}]`) : '';
+            return `${color.cyan(s.name.padEnd(15))} ${color.dim('|')} ${s.localDir.padEnd(
+              20
+            )} ${color.dim('↔')} ${s.folderId.slice(0, 12)}... ${color.dim(
+              `(${s.pattern})`
+            )}${ignoreInfo}${backupInfo}`;
           })
           .join('\n');
 
@@ -373,7 +519,12 @@ const envShow = async () => {
         const lines = config.syncs
           .map((s) => {
             const backupInfo = s.backupDir ? color.yellow(` [backup: ${s.backupDir}]`) : '';
-            return `${color.cyan(s.name.padEnd(15))} ${color.dim('|')} ${s.localDir.padEnd(20)} ${color.dim('↔')} ${s.folderId.slice(0, 12)}... ${color.dim(`(${s.pattern})`)}${backupInfo}`;
+            const ignoreInfo = s.ignore ? color.red(` [ignore: ${s.ignore}]`) : '';
+            return `${color.cyan(s.name.padEnd(15))} ${color.dim('|')} ${s.localDir.padEnd(
+              20
+            )} ${color.dim('↔')} ${s.folderId.slice(0, 12)}... ${color.dim(
+              `(${s.pattern})`
+            )}${ignoreInfo}${backupInfo}`;
           })
           .join('\n');
 
@@ -391,18 +542,116 @@ 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);
   }
 };
 
 /**
- * Match files against pattern
+ * Convert a glob pattern to a regex pattern
+ * Supports:
+ *   - * (matches any characters)
+ *   - ? (matches single character)
+ *   - [abc] (character class)
+ *   - [!abc] or [^abc] (negated character class)
+ *   - regex: prefix for raw regex patterns
+ */
+const globToRegex = (pattern) => {
+  // Raw regex mode: prefix with "regex:"
+  if (pattern.startsWith('regex:')) {
+    return pattern.slice(6);
+  }
+
+  let result = '';
+  let i = 0;
+  while (i < pattern.length) {
+    const char = pattern[i];
+
+    if (char === '*') {
+      result += '.*';
+    } else if (char === '?') {
+      result += '.';
+    } else if (char === '[') {
+      // Find the closing bracket
+      let j = i + 1;
+      let charClass = '[';
+
+      // Handle negation [! or [^
+      if (pattern[j] === '!' || pattern[j] === '^') {
+        charClass += '^';
+        j++;
+      }
+
+      // Find closing bracket
+      while (j < pattern.length && pattern[j] !== ']') {
+        // Escape special regex chars inside character class (except - and ^)
+        if (pattern[j] === '\\' && j + 1 < pattern.length) {
+          charClass += '\\' + pattern[j + 1];
+          j += 2;
+        } else {
+          charClass += pattern[j];
+          j++;
+        }
+      }
+
+      if (j < pattern.length) {
+        charClass += ']';
+        result += charClass;
+        i = j;
+      } else {
+        // No closing bracket found, treat [ as literal
+        result += '\\[';
+      }
+    } else if ('.+^${}|()\\'.includes(char)) {
+      // Escape special regex characters
+      result += '\\' + char;
+    } else {
+      result += char;
+    }
+    i++;
+  }
+
+  return result;
+};
+
+/**
+ * Match files against pattern, with optional ignore pattern
+ * @param {string} filename - The filename to test
+ * @param {string} pattern - Glob pattern or regex: prefixed pattern
+ * @param {string} [ignore] - Optional ignore pattern
+ * @returns {boolean} - True if filename matches pattern and doesn't match ignore
  */
-const matchPattern = (filename, pattern) => {
-  if (pattern === '*') return true;
-  const regex = new RegExp('^' + pattern.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$');
-  return regex.test(filename);
+const matchPattern = (filename, pattern, ignore) => {
+  if (pattern === '*' && !ignore) return true;
+
+  const regexPattern = globToRegex(pattern);
+  const regex = new RegExp('^' + regexPattern + '$');
+  if (!regex.test(filename)) return false;
+
+  if (ignore) {
+    const ignoreRegexPattern = globToRegex(ignore);
+    const ignoreRegex = new RegExp('^' + ignoreRegexPattern + '$');
+    if (ignoreRegex.test(filename)) return false;
+  }
+
+  return true;
 };
 
 /**
@@ -445,19 +694,38 @@ const envRun = async (presetAction, presetConfigType) => {
 
     if (localConfig) {
       const lc = loadConfig(localConfig.configPath);
-      localSyncs = (lc.syncs || []).map((s) => ({ ...s, _configType: 'local', _configPath: localConfig.configPath, _projectRoot: localConfig.projectRoot, _globalBackupDir: lc.backupDir }));
+      localSyncs = (lc.syncs || []).map((s) => ({
+        ...s,
+        _configType: 'local',
+        _configPath: localConfig.configPath,
+        _projectRoot: localConfig.projectRoot,
+        _globalBackupDir: lc.backupDir,
+      }));
     }
     if (globalConfig) {
       const gc = loadConfig(globalConfig.configPath);
-      globalSyncs = (gc.syncs || []).map((s) => ({ ...s, _configType: 'global', _configPath: globalConfig.configPath, _projectRoot: globalConfig.projectRoot, _globalBackupDir: gc.backupDir }));
+      globalSyncs = (gc.syncs || []).map((s) => ({
+        ...s,
+        _configType: 'global',
+        _configPath: globalConfig.configPath,
+        _projectRoot: globalConfig.projectRoot,
+        _globalBackupDir: gc.backupDir,
+      }));
     }
 
-    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;
 
@@ -473,25 +741,90 @@ const envRun = async (presetAction, presetConfigType) => {
       }
       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;
@@ -533,9 +866,10 @@ const envRun = async (presetAction, presetConfigType) => {
     for (const syncConfig of selectedSyncs) {
       const projectRoot = syncConfig._configType === 'global' ? '' : syncConfig._projectRoot;
       const globalBackupDir = syncConfig._globalBackupDir || 'gdrive-backups';
-      const backupPath = syncConfig._configType === 'global'
-        ? (syncConfig.backupDir || path.join(os.homedir(), 'gdrive-backups'))
-        : path.join(projectRoot, syncConfig.backupDir || globalBackupDir);
+      const backupPath =
+        syncConfig._configType === 'global'
+          ? syncConfig.backupDir || path.join(os.homedir(), 'gdrive-backups')
+          : path.join(projectRoot, syncConfig.backupDir || globalBackupDir);
 
       await runSyncOperation(syncConfig, action, projectRoot, backupPath, syncConfig._configType);
     }
@@ -548,14 +882,19 @@ const envRun = async (presetAction, presetConfigType) => {
  * Run a single sync operation
  */
 const runSyncOperation = async (syncConfig, action, projectRoot, backupPath, configType) => {
-  const { folderId, pattern, name } = syncConfig;
+  const { folderId, pattern, name, ignore } = syncConfig;
   // Strip quotes from paths (in case manually added)
   const localDir = syncConfig.localDir.replace(/^['"]|['"]$/g, '');
   // For global config, localDir is absolute; for local, it's relative
   const envDir = configType === 'global' ? localDir : path.join(projectRoot, localDir);
 
+  const ignoreInfo = ignore ? `\n${color.cyan('Ignore:')} ${ignore}` : '';
   note(
-    `${color.cyan('Sync:')} ${name} ${color.dim(`[${configType}]`)}\n${color.cyan('Folder ID:')} ${folderId}\n${color.cyan('Local Dir:')} ${envDir}\n${color.cyan('Pattern:')} ${pattern}\n${color.cyan('Backup Dir:')} ${backupPath}`,
+    `${color.cyan('Sync:')} ${name} ${color.dim(`[${configType}]`)}\n${color.cyan(
+      'Folder ID:'
+    )} ${folderId}\n${color.cyan('Local Dir:')} ${envDir}\n${color.cyan(
+      'Pattern:'
+    )} ${pattern}${ignoreInfo}\n${color.cyan('Backup Dir:')} ${backupPath}`,
     'Processing'
   );
 
@@ -568,10 +907,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 = 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'));
@@ -590,7 +928,7 @@ const runSyncOperation = async (syncConfig, action, projectRoot, backupPath, con
         if (parts.length >= 2) {
           const fileId = parts[0].trim();
           const fileName = parts[1].trim();
-          if (matchPattern(fileName, pattern)) {
+          if (matchPattern(fileName, pattern, ignore)) {
             driveFiles.push({ id: fileId, name: fileName });
           }
         }
@@ -606,7 +944,7 @@ const runSyncOperation = async (syncConfig, action, projectRoot, backupPath, con
 
     // Get local files
     fs.ensureDirSync(envDir);
-    const localFiles = fs.readdirSync(envDir).filter((f) => matchPattern(f, pattern));
+    const localFiles = fs.readdirSync(envDir).filter((f) => matchPattern(f, pattern, ignore));
 
     // Compare files
     const changes = {
@@ -639,9 +977,7 @@ const runSyncOperation = async (syncConfig, action, projectRoot, backupPath, con
     }
 
     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;
 
     if (!hasChanges) {
       log.success('No changes detected. Local and Drive are in sync.');
@@ -728,7 +1064,7 @@ const runSyncOperation = async (syncConfig, action, projectRoot, backupPath, con
 
     if (action === 'download') {
       // Create backup first
-      const existingFiles = fs.readdirSync(envDir).filter((f) => matchPattern(f, pattern));
+      const existingFiles = fs.readdirSync(envDir).filter((f) => matchPattern(f, pattern, ignore));
       if (existingFiles.length > 0) {
         const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
         const backupSubdir = path.join(backupPath, `${name}_${timestamp}`);
@@ -756,7 +1092,6 @@ 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...');
@@ -767,13 +1102,17 @@ 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 });
+          shell.exec(`gdrive update "${driveFile.id}" "${path.join(envDir, filename)}"`, {
+            silent: true,
+          });
           replaced++;
         }
       }
 
       for (const filename of changes.localOnly) {
-        shell.exec(`gdrive upload "${path.join(envDir, filename)}" --parent "${folderId}"`, { silent: true });
+        shell.exec(`gdrive upload "${path.join(envDir, filename)}" --parent "${folderId}"`, {
+          silent: true,
+        });
         uploaded++;
       }
 
@@ -791,4 +1130,9 @@ module.exports = {
   envRun,
   envShow,
   envRemove,
+  envRegister,
+  envUnregister,
+  // Exported for testing
+  globToRegex,
+  matchPattern,
 };

package/src/envSync.test.js

@@ -0,0 +1,189 @@
+const { globToRegex, matchPattern } = require('./envSync');
+
+describe('globToRegex', () => {
+  describe('basic glob patterns (backward compatibility)', () => {
+    test('* matches any characters', () => {
+      expect(globToRegex('*')).toBe('.*');
+      expect(globToRegex('.env.*')).toBe('\\.env\\..*');
+      expect(globToRegex('*.js')).toBe('.*\\.js');
+    });
+
+    test('dots are escaped', () => {
+      expect(globToRegex('.env')).toBe('\\.env');
+      expect(globToRegex('file.txt')).toBe('file\\.txt');
+    });
+
+    test('multiple wildcards', () => {
+      expect(globToRegex('*.*')).toBe('.*\\..*');
+    });
+  });
+
+  describe('? single character wildcard', () => {
+    test('? matches single character', () => {
+      expect(globToRegex('file?.txt')).toBe('file.\\.txt');
+      expect(globToRegex('???.js')).toBe('...\\.js');
+    });
+
+    test('combined with *', () => {
+      expect(globToRegex('file?.*')).toBe('file.\\..*');
+    });
+  });
+
+  describe('character classes [abc]', () => {
+    test('basic character class', () => {
+      expect(globToRegex('[abc]')).toBe('[abc]');
+      expect(globToRegex('file[123].txt')).toBe('file[123]\\.txt');
+    });
+
+    test('character range', () => {
+      expect(globToRegex('[a-z]')).toBe('[a-z]');
+      expect(globToRegex('[0-9]')).toBe('[0-9]');
+    });
+
+    test('negated character class with !', () => {
+      expect(globToRegex('[!abc]')).toBe('[^abc]');
+      expect(globToRegex('[!0-9]')).toBe('[^0-9]');
+    });
+
+    test('negated character class with ^', () => {
+      expect(globToRegex('[^abc]')).toBe('[^abc]');
+    });
+
+    test('character class with special chars', () => {
+      expect(globToRegex('[.-]')).toBe('[.-]');
+    });
+
+    test('unclosed bracket treated as literal', () => {
+      expect(globToRegex('[abc')).toBe('\\[abc');
+    });
+  });
+
+  describe('regex: prefix for raw regex', () => {
+    test('passes through raw regex unchanged', () => {
+      expect(globToRegex('regex:\\.env\\.[^.]+$')).toBe('\\.env\\.[^.]+$');
+      expect(globToRegex('regex:.*\\.js$')).toBe('.*\\.js$');
+    });
+
+    test('complex regex patterns', () => {
+      expect(globToRegex('regex:^(foo|bar)\\.(js|ts)$')).toBe('^(foo|bar)\\.(js|ts)$');
+    });
+  });
+
+  describe('special regex characters are escaped', () => {
+    test('escapes + ^ $ { } | ( ) \\', () => {
+      expect(globToRegex('file+name')).toBe('file\\+name');
+      expect(globToRegex('file^name')).toBe('file\\^name');
+      expect(globToRegex('file$name')).toBe('file\\$name');
+      expect(globToRegex('file(1)')).toBe('file\\(1\\)');
+      expect(globToRegex('file{1}')).toBe('file\\{1\\}');
+      expect(globToRegex('a|b')).toBe('a\\|b');
+    });
+  });
+});
+
+describe('matchPattern', () => {
+  describe('backward compatibility - basic glob', () => {
+    test('* matches everything', () => {
+      expect(matchPattern('anything.txt', '*')).toBe(true);
+      expect(matchPattern('.env.development', '*')).toBe(true);
+    });
+
+    test('.env.* pattern', () => {
+      expect(matchPattern('.env.development', '.env.*')).toBe(true);
+      expect(matchPattern('.env.production', '.env.*')).toBe(true);
+      expect(matchPattern('.env.local', '.env.*')).toBe(true);
+      expect(matchPattern('.env.development.template', '.env.*')).toBe(true);
+      expect(matchPattern('.envrc', '.env.*')).toBe(false);
+      expect(matchPattern('config.env.js', '.env.*')).toBe(false);
+    });
+
+    test('*.js pattern', () => {
+      expect(matchPattern('index.js', '*.js')).toBe(true);
+      expect(matchPattern('app.test.js', '*.js')).toBe(true);
+      expect(matchPattern('index.ts', '*.js')).toBe(false);
+    });
+  });
+
+  describe('? single character', () => {
+    test('matches single character', () => {
+      expect(matchPattern('file1.txt', 'file?.txt')).toBe(true);
+      expect(matchPattern('fileA.txt', 'file?.txt')).toBe(true);
+      expect(matchPattern('file12.txt', 'file?.txt')).toBe(false);
+      expect(matchPattern('file.txt', 'file?.txt')).toBe(false);
+    });
+  });
+
+  describe('character classes', () => {
+    test('[abc] matches specific characters', () => {
+      expect(matchPattern('filea.txt', 'file[abc].txt')).toBe(true);
+      expect(matchPattern('fileb.txt', 'file[abc].txt')).toBe(true);
+      expect(matchPattern('filed.txt', 'file[abc].txt')).toBe(false);
+    });
+
+    test('[0-9] matches digit range', () => {
+      expect(matchPattern('file5.txt', 'file[0-9].txt')).toBe(true);
+      expect(matchPattern('filea.txt', 'file[0-9].txt')).toBe(false);
+    });
+
+    test('[!abc] negated class', () => {
+      expect(matchPattern('filed.txt', 'file[!abc].txt')).toBe(true);
+      expect(matchPattern('filea.txt', 'file[!abc].txt')).toBe(false);
+    });
+
+    test('[!.] matches non-dot (for excluding .template)', () => {
+      expect(matchPattern('.env.development', '.env.[!.]*')).toBe(true);
+      expect(matchPattern('.env.production', '.env.[!.]*')).toBe(true);
+      // This won't fully exclude .template because [!.]* only affects first char
+      // Use ignore pattern instead for this use case
+    });
+  });
+
+  describe('regex: prefix', () => {
+    test('raw regex for complex patterns', () => {
+      expect(matchPattern('.env.development', 'regex:\\.env\\.[^.]+$')).toBe(true);
+      expect(matchPattern('.env.production', 'regex:\\.env\\.[^.]+$')).toBe(true);
+      expect(matchPattern('.env.development.template', 'regex:\\.env\\.[^.]+$')).toBe(false);
+    });
+
+    test('regex with alternation', () => {
+      expect(matchPattern('app.js', 'regex:.*\\.(js|ts)$')).toBe(true);
+      expect(matchPattern('app.ts', 'regex:.*\\.(js|ts)$')).toBe(true);
+      expect(matchPattern('app.css', 'regex:.*\\.(js|ts)$')).toBe(false);
+    });
+  });
+
+  describe('ignore pattern', () => {
+    test('excludes files matching ignore', () => {
+      expect(matchPattern('.env.development', '.env.*', '*.template')).toBe(true);
+      expect(matchPattern('.env.development.template', '.env.*', '*.template')).toBe(false);
+      expect(matchPattern('.env.production.template', '.env.*', '*.template')).toBe(false);
+    });
+
+    test('ignore with character class', () => {
+      expect(matchPattern('file1.txt', '*.txt', 'file[0-9].txt')).toBe(false);
+      expect(matchPattern('fileA.txt', '*.txt', 'file[0-9].txt')).toBe(true);
+    });
+
+    test('ignore with regex:', () => {
+      expect(matchPattern('.env.dev', '.env.*', 'regex:.*\\.template$')).toBe(true);
+      expect(matchPattern('.env.dev.template', '.env.*', 'regex:.*\\.template$')).toBe(false);
+    });
+  });
+
+  describe('edge cases', () => {
+    test('empty pattern', () => {
+      expect(matchPattern('', '')).toBe(true);
+      expect(matchPattern('file.txt', '')).toBe(false);
+    });
+
+    test('exact match', () => {
+      expect(matchPattern('.env', '.env')).toBe(true);
+      expect(matchPattern('.env.local', '.env')).toBe(false);
+    });
+
+    test('pattern with no wildcards', () => {
+      expect(matchPattern('config.json', 'config.json')).toBe(true);
+      expect(matchPattern('config.yaml', 'config.json')).toBe(false);
+    });
+  });
+});