gdrive-syncer 2.1.2 → 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
 
@@ -180,6 +182,36 @@ 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
+
+### 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,6 +1,6 @@
 {
   "name": "gdrive-syncer",
-  "version": "2.1.2",
+  "version": "2.2.0",
   "description": "Google Drive Syncer",
   "main": "./index.js",
   "bin": "./run.js",

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
 };
 
 /**
@@ -359,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
  */
@@ -427,6 +542,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 +713,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;
 
@@ -602,33 +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;
@@ -934,6 +1130,8 @@ module.exports = {
   envRun,
   envShow,
   envRemove,
+  envRegister,
+  envUnregister,
   // Exported for testing
   globToRegex,
   matchPattern,