gdrive-syncer 3.0.0 → 3.1.1

package/src/gdriveCmd.js

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 
 const shell = require('shelljs');
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const execAsync = promisify(exec);
 
 let cachedVersion = null;
 
@@ -254,7 +257,7 @@ const syncList = () => {
  * 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}>}
+ * @returns {Array<{id: string, name: string, type: string, size: string, sizeBytes: number, date: string, modifiedTime: Date|null}>}
  */
 const parseListOutput = (stdout) => {
   const lines = stdout.trim().split('\n').filter((line) => line.trim());
@@ -267,16 +270,64 @@ const parseListOutput = (stdout) => {
 
   return lines.map((line) => {
     const parts = line.trim().split(separator);
+    const size = parts[3] || '';
+    const date = parts[4] || '';
+
     return {
       id: parts[0] || '',
       name: parts[1] || '',
       type: parts[2] || '',
-      size: parts[3] || '',
-      date: parts[4] || '',
+      size,
+      sizeBytes: parseSizeToBytes(size),
+      date,
+      modifiedTime: parseGdriveDate(date),
     };
   });
 };
 
+/**
+ * Parse size string to bytes (e.g., "1.5 KB" -> 1536)
+ * @param {string} sizeStr - Size string from gdrive output
+ * @returns {number} - Size in bytes, or 0 if unparseable
+ */
+const parseSizeToBytes = (sizeStr) => {
+  if (!sizeStr) return 0;
+
+  const match = sizeStr.match(/^([\d.]+)\s*(B|KB|MB|GB|TB)?$/i);
+  if (!match) return 0;
+
+  const value = parseFloat(match[1]);
+  const unit = (match[2] || 'B').toUpperCase();
+
+  const multipliers = {
+    B: 1,
+    KB: 1024,
+    MB: 1024 * 1024,
+    GB: 1024 * 1024 * 1024,
+    TB: 1024 * 1024 * 1024 * 1024,
+  };
+
+  return Math.round(value * (multipliers[unit] || 1));
+};
+
+/**
+ * Parse gdrive date string to Date object
+ * gdrive outputs dates like "2024-01-15 10:30:00" or ISO format
+ * @param {string} dateStr - Date string from gdrive output
+ * @returns {Date|null} - Date object or null if unparseable
+ */
+const parseGdriveDate = (dateStr) => {
+  if (!dateStr) return null;
+
+  // Try parsing as-is (handles ISO format and common formats)
+  const date = new Date(dateStr);
+  if (!isNaN(date.getTime())) {
+    return date;
+  }
+
+  return null;
+};
+
 /**
  * Clear the cached version (useful for testing)
  */
@@ -284,12 +335,112 @@ const clearCache = () => {
   cachedVersion = null;
 };
 
+/**
+ * Async version of list - for parallel operations
+ * @param {Object} options - Same options as list()
+ * @returns {Promise<{code: number, stdout: string, stderr: string}>}
+ */
+const listAsync = async (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';
+  }
+
+  try {
+    const { stdout, stderr } = await execAsync(cmd);
+    return { code: 0, stdout: stdout || '', stderr: stderr || '' };
+  } catch (error) {
+    return { code: error.code || 1, stdout: error.stdout || '', stderr: error.stderr || error.message };
+  }
+};
+
+/**
+ * Async version of download - for parallel downloads
+ * @param {string} fileId - File ID to download
+ * @param {Object} options - Same options as download()
+ * @returns {Promise<{code: number, stdout: string, stderr: string}>}
+ */
+const downloadAsync = async (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';
+  }
+
+  try {
+    const { stdout, stderr } = await execAsync(cmd);
+    return { code: 0, stdout: stdout || '', stderr: stderr || '' };
+  } catch (error) {
+    return { code: error.code || 1, stdout: error.stdout || '', stderr: error.stderr || error.message };
+  }
+};
+
+/**
+ * Download multiple files in parallel with concurrency limit and progress tracking
+ * @param {Array<{fileId: string, options: Object}>} downloads - Array of download requests
+ * @param {number} concurrency - Maximum concurrent downloads (default: 5)
+ * @param {Function} [onProgress] - Progress callback: (completed, total) => void
+ * @returns {Promise<Array<{code: number, stdout: string, stderr: string}>>}
+ */
+const downloadParallel = async (downloads, concurrency = 5, onProgress = null) => {
+  const results = [];
+  const total = downloads.length;
+  let completed = 0;
+
+  // Process in batches to limit concurrency
+  for (let i = 0; i < downloads.length; i += concurrency) {
+    const batch = downloads.slice(i, i + concurrency);
+    const batchResults = await Promise.all(
+      batch.map(async ({ fileId, options }) => {
+        const result = await downloadAsync(fileId, options);
+        completed++;
+        if (onProgress) {
+          onProgress(completed, total);
+        }
+        return result;
+      })
+    );
+    results.push(...batchResults);
+  }
+
+  return results;
+};
+
 module.exports = {
   detectVersion,
   getVersion,
   hasSyncSupport,
   list,
+  listAsync,
   download,
+  downloadAsync,
+  downloadParallel,
   upload,
   update,
   mkdir,
@@ -297,5 +448,7 @@ module.exports = {
   syncUpload,
   syncList,
   parseListOutput,
+  parseSizeToBytes,
+  parseGdriveDate,
   clearCache,
 };

package/src/versionCheck.js

@@ -0,0 +1,100 @@
+/**
+ * Version check utility - warns user if a newer version is available
+ */
+const https = require('https');
+const path = require('path');
+const color = require('picocolors');
+
+// Get current version from package.json
+const getLocalVersion = () => {
+  const pkg = require(path.join(__dirname, '..', 'package.json'));
+  return pkg.version;
+};
+
+// Get package name from package.json
+const getPackageName = () => {
+  const pkg = require(path.join(__dirname, '..', 'package.json'));
+  return pkg.name;
+};
+
+/**
+ * Fetch latest version from npm registry
+ * @param {string} packageName - npm package name
+ * @returns {Promise<string|null>} - Latest version or null on error
+ */
+const fetchLatestVersion = (packageName) => {
+  return new Promise((resolve) => {
+    const url = `https://registry.npmjs.org/${packageName}/latest`;
+
+    const req = https.get(url, { timeout: 3000 }, (res) => {
+      let data = '';
+
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(data);
+          resolve(json.version || null);
+        } catch {
+          resolve(null);
+        }
+      });
+    });
+
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => {
+      req.destroy();
+      resolve(null);
+    });
+  });
+};
+
+/**
+ * Compare semver versions
+ * @param {string} current - Current version (e.g., "1.2.3")
+ * @param {string} latest - Latest version (e.g., "1.3.0")
+ * @returns {boolean} - True if latest is newer than current
+ */
+const isNewerVersion = (current, latest) => {
+  const currentParts = current.split('.').map(Number);
+  const latestParts = latest.split('.').map(Number);
+
+  for (let i = 0; i < 3; i++) {
+    const c = currentParts[i] || 0;
+    const l = latestParts[i] || 0;
+    if (l > c) return true;
+    if (l < c) return false;
+  }
+  return false;
+};
+
+/**
+ * Check for updates and return message if newer version available
+ * Non-blocking - doesn't throw errors, just silently fails
+ * @returns {Promise<string|null>} - Update message or null if up to date/error
+ */
+const checkForUpdates = async () => {
+  try {
+    const packageName = getPackageName();
+    const currentVersion = getLocalVersion();
+    const latestVersion = await fetchLatestVersion(packageName);
+
+    if (latestVersion && isNewerVersion(currentVersion, latestVersion)) {
+      return `Update available: ${color.dim(currentVersion)} → ${color.green(latestVersion)} (${color.cyan(packageName)})`;
+    }
+    return null;
+  } catch {
+    // Silently ignore errors - don't disrupt user experience
+    return null;
+  }
+};
+
+module.exports = {
+  getLocalVersion,
+  getPackageName,
+  fetchLatestVersion,
+  isNewerVersion,
+  checkForUpdates,
+};