@hasna/connectors 1.3.22 → 1.3.23

package/connectors/connect-googledrive/src/cli/index.ts

@@ -1303,5 +1303,629 @@ drivesCmd
     }
   });
 
+// ============================================
+// Bulk Commands
+// ============================================
+const bulkCmd = program
+  .command('bulk')
+  .description('Bulk operations on files (using Drive search queries)');
+
+bulkCmd
+  .command('preview <query>')
+  .description('Preview files matching a Drive search query')
+  .option('-n, --max <number>', 'Maximum files to preview', '20')
+  .action(async (query: string, opts) => {
+    try {
+      const drive = requireAuth();
+      info(`Searching for files matching: ${query}`);
+
+      const result = await drive.bulk.preview(query, parseInt(opts.max));
+
+      if (result.files.length === 0) {
+        info('No files found matching the query');
+        return;
+      }
+
+      success(`Found ${result.total} file(s):`);
+      const output = result.files.map(f => ({
+        id: f.id,
+        name: f.name,
+        mimeType: f.mimeType,
+        size: f.size ? formatBytes(parseInt(f.size)) : '-',
+      }));
+      print(output, getFormat(bulkCmd));
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+bulkCmd
+  .command('trash <query>')
+  .description('Move files matching a query to trash')
+  .option('-n, --max <number>', 'Maximum files to process', '100')
+  .option('-c, --concurrency <number>', 'Maximum concurrent API calls', '10')
+  .option('--dry-run', 'Preview changes without applying them')
+  .action(async (query: string, opts) => {
+    try {
+      const drive = requireAuth();
+      info(`${opts.dryRun ? '[DRY RUN] ' : ''}Moving to trash files matching: ${query}`);
+
+      const result = await drive.bulk.trash({
+        query,
+        maxResults: parseInt(opts.max),
+        concurrency: parseInt(opts.concurrency),
+        dryRun: opts.dryRun,
+        onProgress: (current, total) => {
+          process.stdout.write(`\r  Progress: ${current}/${total}`);
+        },
+      });
+      console.log();
+
+      success(`${opts.dryRun ? '[DRY RUN] ' : ''}Bulk trash complete:`);
+      info(`  Total: ${result.total}`);
+      info(`  Success: ${result.success}`);
+      if (result.failed > 0) warn(`  Failed: ${result.failed}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+bulkCmd
+  .command('delete <query>')
+  .description('Permanently delete files matching a query (DANGER!)')
+  .option('-n, --max <number>', 'Maximum files to process', '100')
+  .option('-c, --concurrency <number>', 'Maximum concurrent API calls', '10')
+  .option('--dry-run', 'Preview changes without applying them')
+  .option('--trash', 'Move to trash instead of permanent delete')
+  .option('--confirm', 'Confirm permanent deletion')
+  .action(async (query: string, opts) => {
+    try {
+      if (!opts.dryRun && !opts.confirm && !opts.trash) {
+        error('Permanent deletion requires --confirm flag');
+        info('Use --dry-run to preview or --trash to move to trash instead');
+        process.exit(1);
+      }
+
+      const drive = requireAuth();
+      if (!opts.trash) {
+        warn(`${opts.dryRun ? '[DRY RUN] ' : ''}PERMANENTLY DELETING files matching: ${query}`);
+      } else {
+        info(`${opts.dryRun ? '[DRY RUN] ' : ''}Moving to trash files matching: ${query}`);
+      }
+
+      const result = await drive.bulk.delete({
+        query,
+        maxResults: parseInt(opts.max),
+        concurrency: parseInt(opts.concurrency),
+        trash: opts.trash,
+        dryRun: opts.dryRun,
+        onProgress: (current, total) => {
+          process.stdout.write(`\r  Progress: ${current}/${total}`);
+        },
+      });
+      console.log();
+
+      success(`${opts.dryRun ? '[DRY RUN] ' : ''}Bulk delete complete:`);
+      info(`  Total: ${result.total}`);
+      info(`  Success: ${result.success}`);
+      if (result.failed > 0) warn(`  Failed: ${result.failed}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+bulkCmd
+  .command('untrash <query>')
+  .description('Restore files matching a query from trash')
+  .option('-n, --max <number>', 'Maximum files to process', '100')
+  .option('-c, --concurrency <number>', 'Maximum concurrent API calls', '10')
+  .option('--dry-run', 'Preview changes without applying them')
+  .action(async (query: string, opts) => {
+    try {
+      const drive = requireAuth();
+      info(`${opts.dryRun ? '[DRY RUN] ' : ''}Restoring from trash files matching: ${query}`);
+
+      const result = await drive.bulk.untrash({
+        query,
+        maxResults: parseInt(opts.max),
+        concurrency: parseInt(opts.concurrency),
+        dryRun: opts.dryRun,
+        onProgress: (current, total) => {
+          process.stdout.write(`\r  Progress: ${current}/${total}`);
+        },
+      });
+      console.log();
+
+      success(`${opts.dryRun ? '[DRY RUN] ' : ''}Bulk untrash complete:`);
+      info(`  Total: ${result.total}`);
+      info(`  Success: ${result.success}`);
+      if (result.failed > 0) warn(`  Failed: ${result.failed}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+bulkCmd
+  .command('move <query> <destinationFolderId>')
+  .description('Move files matching a query to a different folder')
+  .option('-n, --max <number>', 'Maximum files to process', '100')
+  .option('-c, --concurrency <number>', 'Maximum concurrent API calls', '10')
+  .option('--dry-run', 'Preview changes without applying them')
+  .action(async (query: string, destinationFolderId: string, opts) => {
+    try {
+      const drive = requireAuth();
+      info(`${opts.dryRun ? '[DRY RUN] ' : ''}Moving files matching: ${query}`);
+      info(`  Destination folder: ${destinationFolderId}`);
+
+      const result = await drive.bulk.move({
+        query,
+        destinationFolderId,
+        maxResults: parseInt(opts.max),
+        concurrency: parseInt(opts.concurrency),
+        dryRun: opts.dryRun,
+        onProgress: (current, total) => {
+          process.stdout.write(`\r  Progress: ${current}/${total}`);
+        },
+      });
+      console.log();
+
+      success(`${opts.dryRun ? '[DRY RUN] ' : ''}Bulk move complete:`);
+      info(`  Total: ${result.total}`);
+      info(`  Success: ${result.success}`);
+      if (result.failed > 0) warn(`  Failed: ${result.failed}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+bulkCmd
+  .command('rename <query>')
+  .description('Rename files matching a query')
+  .option('-n, --max <number>', 'Maximum files to process', '100')
+  .option('-c, --concurrency <number>', 'Maximum concurrent API calls', '10')
+  .option('--dry-run', 'Preview changes without applying them')
+  .option('-m, --mode <mode>', 'Rename mode: prefix, suffix, replace, lowercase, uppercase', 'prefix')
+  .option('--prefix <text>', 'Prefix to add (for mode=prefix)')
+  .option('--suffix <text>', 'Suffix to add before extension (for mode=suffix)')
+  .option('--find <text>', 'Text to find (for mode=replace)')
+  .option('--replace <text>', 'Replacement text (for mode=replace)')
+  .action(async (query: string, opts) => {
+    try {
+      const drive = requireAuth();
+      const mode = opts.mode as 'prefix' | 'suffix' | 'replace' | 'lowercase' | 'uppercase';
+
+      info(`${opts.dryRun ? '[DRY RUN] ' : ''}Renaming files matching: ${query}`);
+      info(`  Mode: ${mode}`);
+      if (opts.prefix) info(`  Prefix: ${opts.prefix}`);
+      if (opts.suffix) info(`  Suffix: ${opts.suffix}`);
+      if (opts.find) info(`  Find: ${opts.find}`);
+      if (opts.replace) info(`  Replace: ${opts.replace}`);
+
+      const result = await drive.bulk.rename({
+        query,
+        mode,
+        prefix: opts.prefix,
+        suffix: opts.suffix,
+        find: opts.find,
+        replace: opts.replace,
+        maxResults: parseInt(opts.max),
+        concurrency: parseInt(opts.concurrency),
+        dryRun: opts.dryRun,
+        onProgress: (current, total) => {
+          process.stdout.write(`\r  Progress: ${current}/${total}`);
+        },
+      });
+      console.log();
+
+      success(`${opts.dryRun ? '[DRY RUN] ' : ''}Bulk rename complete:`);
+      info(`  Total: ${result.total}`);
+      info(`  Success: ${result.success}`);
+      if (result.failed > 0) warn(`  Failed: ${result.failed}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+bulkCmd
+  .command('share <query>')
+  .description('Share files matching a query with a user')
+  .option('-n, --max <number>', 'Maximum files to process', '100')
+  .option('-c, --concurrency <number>', 'Maximum concurrent API calls', '10')
+  .option('--dry-run', 'Preview changes without applying them')
+  .option('-e, --email <email>', 'Email address to share with (required)', '')
+  .option('-r, --role <role>', 'Permission role: reader, writer, commenter', 'reader')
+  .option('--no-notification', 'Do not send notification email')
+  .action(async (query: string, opts) => {
+    try {
+      if (!opts.email) {
+        error('--email is required');
+        process.exit(1);
+      }
+
+      const drive = requireAuth();
+      info(`${opts.dryRun ? '[DRY RUN] ' : ''}Sharing files matching: ${query}`);
+      info(`  With: ${opts.email} (${opts.role})`);
+
+      const result = await drive.bulk.share({
+        query,
+        email: opts.email,
+        role: opts.role as 'reader' | 'writer' | 'commenter',
+        sendNotification: opts.notification !== false,
+        maxResults: parseInt(opts.max),
+        concurrency: parseInt(opts.concurrency),
+        dryRun: opts.dryRun,
+        onProgress: (current, total) => {
+          process.stdout.write(`\r  Progress: ${current}/${total}`);
+        },
+      });
+      console.log();
+
+      success(`${opts.dryRun ? '[DRY RUN] ' : ''}Bulk share complete:`);
+      info(`  Total: ${result.total}`);
+      info(`  Success: ${result.success}`);
+      if (result.failed > 0) warn(`  Failed: ${result.failed}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+bulkCmd
+  .command('make-public <query>')
+  .description('Make files matching a query publicly accessible')
+  .option('-n, --max <number>', 'Maximum files to process', '100')
+  .option('-c, --concurrency <number>', 'Maximum concurrent API calls', '10')
+  .option('--dry-run', 'Preview changes without applying them')
+  .action(async (query: string, opts) => {
+    try {
+      const drive = requireAuth();
+      warn(`${opts.dryRun ? '[DRY RUN] ' : ''}MAKING PUBLICLY ACCESSIBLE files matching: ${query}`);
+
+      const result = await drive.bulk.makePublic({
+        query,
+        maxResults: parseInt(opts.max),
+        concurrency: parseInt(opts.concurrency),
+        dryRun: opts.dryRun,
+        onProgress: (current, total) => {
+          process.stdout.write(`\r  Progress: ${current}/${total}`);
+        },
+      });
+      console.log();
+
+      success(`${opts.dryRun ? '[DRY RUN] ' : ''}Bulk make-public complete:`);
+      info(`  Total: ${result.total}`);
+      info(`  Success: ${result.success}`);
+      if (result.failed > 0) warn(`  Failed: ${result.failed}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+bulkCmd
+  .command('remove-public <query>')
+  .description('Remove public access from files matching a query')
+  .option('-n, --max <number>', 'Maximum files to process', '100')
+  .option('-c, --concurrency <number>', 'Maximum concurrent API calls', '10')
+  .option('--dry-run', 'Preview changes without applying them')
+  .action(async (query: string, opts) => {
+    try {
+      const drive = requireAuth();
+      info(`${opts.dryRun ? '[DRY RUN] ' : ''}Removing public access from files matching: ${query}`);
+
+      const result = await drive.bulk.removePublicAccess({
+        query,
+        maxResults: parseInt(opts.max),
+        concurrency: parseInt(opts.concurrency),
+        dryRun: opts.dryRun,
+        onProgress: (current, total) => {
+          process.stdout.write(`\r  Progress: ${current}/${total}`);
+        },
+      });
+      console.log();
+
+      success(`${opts.dryRun ? '[DRY RUN] ' : ''}Bulk remove-public complete:`);
+      info(`  Total: ${result.total}`);
+      info(`  Success: ${result.success}`);
+      if (result.failed > 0) warn(`  Failed: ${result.failed}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+bulkCmd
+  .command('star <query>')
+  .description('Star files matching a query')
+  .option('-n, --max <number>', 'Maximum files to process', '100')
+  .option('-c, --concurrency <number>', 'Maximum concurrent API calls', '10')
+  .option('--dry-run', 'Preview changes without applying them')
+  .action(async (query: string, opts) => {
+    try {
+      const drive = requireAuth();
+      info(`${opts.dryRun ? '[DRY RUN] ' : ''}Starring files matching: ${query}`);
+
+      const result = await drive.bulk.star({
+        query,
+        maxResults: parseInt(opts.max),
+        concurrency: parseInt(opts.concurrency),
+        dryRun: opts.dryRun,
+        onProgress: (current, total) => {
+          process.stdout.write(`\r  Progress: ${current}/${total}`);
+        },
+      });
+      console.log();
+
+      success(`${opts.dryRun ? '[DRY RUN] ' : ''}Bulk star complete:`);
+      info(`  Total: ${result.total}`);
+      info(`  Success: ${result.success}`);
+      if (result.failed > 0) warn(`  Failed: ${result.failed}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+bulkCmd
+  .command('unstar <query>')
+  .description('Remove stars from files matching a query')
+  .option('-n, --max <number>', 'Maximum files to process', '100')
+  .option('-c, --concurrency <number>', 'Maximum concurrent API calls', '10')
+  .option('--dry-run', 'Preview changes without applying them')
+  .action(async (query: string, opts) => {
+    try {
+      const drive = requireAuth();
+      info(`${opts.dryRun ? '[DRY RUN] ' : ''}Removing stars from files matching: ${query}`);
+
+      const result = await drive.bulk.unstar({
+        query,
+        maxResults: parseInt(opts.max),
+        concurrency: parseInt(opts.concurrency),
+        dryRun: opts.dryRun,
+        onProgress: (current, total) => {
+          process.stdout.write(`\r  Progress: ${current}/${total}`);
+        },
+      });
+      console.log();
+
+      success(`${opts.dryRun ? '[DRY RUN] ' : ''}Bulk unstar complete:`);
+      info(`  Total: ${result.total}`);
+      info(`  Success: ${result.success}`);
+      if (result.failed > 0) warn(`  Failed: ${result.failed}`);
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+bulkCmd
+  .command('help-query')
+  .description('Show Drive search query syntax examples')
+  .action(() => {
+    info(chalk.bold('\nDrive Search Query Syntax:\n'));
+
+    info(chalk.cyan('Basic filters:'));
+    info('  name = "report"              - Files named "report"');
+    info('  name contains "report"       - Files with "report" in the name');
+    info('  fullName contains "/Docs/"   - Files in a path containing "Docs"\n');
+
+    info(chalk.cyan('Type filters:'));
+    info('  mimeType = "application/pdf" - PDF files only');
+    info('  mimeType = "application/vnd.google-apps.document" - Google Docs');
+    info('  mimeType = "application/vnd.google-apps.folder"   - Folders');
+    info('  mimeType contains "image/"    - Any image file\n');
+
+    info(chalk.cyan('Status filters:'));
+    info('  trashed = false              - Not in trash');
+    info('  trashed = true               - In trash');
+    info('  starred = true               - Starred files');
+    info('  viewedByMe = true            - Files you have viewed\n');
+
+    info(chalk.cyan('Ownership filters:'));
+    info('  "me" in owners               - Files you own');
+    info('  sharedWithMe                 - Files shared with you');
+    info('  "user@example.com" in owners - Files owned by specific user\n');
+
+    info(chalk.cyan('Folder filters:'));
+    info('  "<folderId>" in parents      - Direct children of a folder\n');
+
+    info(chalk.cyan('Date filters:'));
+    info('  modifiedTime > "2024-01-01T00:00:00"  - Modified after date');
+    info('  modifiedTime < "2024-12-31T23:59:59"  - Modified before date');
+    info('  createdTime > "2024-06-01T00:00:00"   - Created after date\n');
+
+    info(chalk.cyan('Combining filters:'));
+    info('  mimeType = "application/pdf" and trashed = false');
+    info('  name contains "report" and "me" in owners');
+    info('  mimeType contains "image/" and modifiedTime > "2024-01-01T00:00:00"\n');
+
+    info(chalk.cyan('Examples:'));
+    info('  bulk preview "mimeType=\'application/pdf\'"');
+    info('  bulk trash "name contains \'temp\' and trashed = false" --dry-run');
+    info('  bulk rename "mimeType contains \'image\'" --mode suffix --suffix _v2');
+    info('  bulk star "sharedWithMe" -n 50');
+  });
+
+// ============================================
+// Changes Commands
+// ============================================
+const changesCmd = program
+  .command('changes')
+  .description('Track changes to Drive files');
+
+changesCmd
+  .command('start-page-token')
+  .description('Get the current starting page token for change tracking')
+  .option('--drive <driveId>', 'Get token for a specific shared drive')
+  .action(async (opts) => {
+    try {
+      const drive = requireAuth();
+      const result = await drive.changes.getStartPageToken({
+        driveId: opts.drive,
+        supportsAllDrives: !!opts.drive,
+      });
+      success('Current page token: ' + result.nextPageToken);
+      info('Use this token with "changes list" to begin tracking');
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+changesCmd
+  .command('list <pageToken>')
+  .description('List changes since the given page token')
+  .option('-n, --max <number>', 'Maximum changes to return', '50')
+  .option('--include-removed', 'Include removed items')
+  .option('--my-drive-only', 'Only track My Drive changes (exclude shared drives)')
+  .action(async (pageToken: string, opts) => {
+    try {
+      const drive = requireAuth();
+      const result = await drive.changes.list({
+        pageToken,
+        pageSize: parseInt(opts.max),
+        includeRemoved: opts.includeRemoved,
+        restrictToMyDrive: opts.myDriveOnly,
+        includeItemsFromAllDrives: !opts.myDriveOnly,
+        supportsAllDrives: true,
+      });
+
+      if (!result.changes || result.changes.length === 0) {
+        info('No changes found');
+        return;
+      }
+
+      success('Found ' + result.changes.length + ' change(s):');
+      info('New start page token: ' + result.newStartPageToken);
+
+      const changes = result.changes.map((c: any) => ({
+        fileId: c.fileId,
+        type: c.type,
+        removed: c.removed || false,
+        fileName: c.file?.name || '-',
+        mimeType: c.file?.mimeType || '-',
+      }));
+
+      print(changes, getFormat(changesCmd));
+
+      if (result.nextPageToken) {
+        info('Next page token: ' + result.nextPageToken);
+      }
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+// ============================================
+// Revisions Commands
+// ============================================
+const revisionsCmd = program
+  .command('revisions')
+  .description('File revision history commands');
+
+revisionsCmd
+  .command('list <fileId>')
+  .description('List revisions of a file')
+  .action(async (fileId: string) => {
+    try {
+      const drive = requireAuth();
+      const result = await drive.revisions.list(fileId);
+
+      if (!result.revisions || result.revisions.length === 0) {
+        info('No revisions found');
+        return;
+      }
+
+      success('Found ' + result.revisions.length + ' revision(s):');
+
+      const revisions = result.revisions.map((r: any) => ({
+        id: r.id,
+        mimeType: r.mimeType,
+        size: r.size ? formatBytes(r.size) : '-',
+        modified: r.modifiedTime ? new Date(r.modifiedTime).toLocaleString() : '-',
+        keepForever: r.keepForever || false,
+      }));
+
+      print(revisions, getFormat(revisionsCmd));
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+revisionsCmd
+  .command('get <fileId> <revisionId>')
+  .description('Get details of a specific revision')
+  .action(async (fileId: string, revisionId: string) => {
+    try {
+      const drive = requireAuth();
+      const revision = await drive.revisions.get(fileId, revisionId);
+      print(revision, getFormat(revisionsCmd));
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+revisionsCmd
+  .command('download <fileId> <revisionId> [destination]')
+  .description('Download a specific revision')
+  .action(async (fileId: string, revisionId: string, destination?: string) => {
+    try {
+      const drive = requireAuth();
+      info('Downloading revision...');
+
+      const data = await drive.revisions.download(fileId, revisionId);
+
+      if (destination) {
+        writeFileSync(destination, Buffer.from(data));
+        success('Downloaded revision to: ' + destination);
+      } else {
+        const destPath = join(process.cwd(), 'revision-' + revisionId);
+        writeFileSync(destPath, Buffer.from(data));
+        success('Downloaded revision');
+        info('Saved to: ' + destPath);
+      }
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+revisionsCmd
+  .command('keep-forever <fileId> <revisionId>')
+  .description('Mark a revision to be kept forever (not auto-deleted)')
+  .action(async (fileId: string, revisionId: string) => {
+    try {
+      const drive = requireAuth();
+      await drive.revisions.update(fileId, revisionId, { keepForever: true });
+      success('Revision marked to keep forever');
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
+revisionsCmd
+  .command('delete <fileId> <revisionId>')
+  .description('Delete a specific revision')
+  .action(async (fileId: string, revisionId: string) => {
+    try {
+      const drive = requireAuth();
+      await drive.revisions.delete(fileId, revisionId);
+      success('Revision deleted');
+    } catch (err) {
+      error(String(err));
+      process.exit(1);
+    }
+  });
+
 // Parse and execute
 program.parse();

package/connectors/connect-googledrive/src/index.ts

@@ -27,4 +27,6 @@ export {
   loadTokens,
   saveTokens,
   clearConfig,
+  setProfileOverride,
+  getProfileOverride,
 } from './utils/config.ts';