appwrite-utils-cli 1.0.7 → 1.0.8

package/dist/migrations/comprehensiveTransfer.js

@@ -0,0 +1,366 @@
+import { converterFunctions, tryAwaitWithRetry } from "appwrite-utils";
+import { Client, Databases, Storage, Users, Functions, Query, } from "node-appwrite";
+import { InputFile } from "node-appwrite/file";
+import { MessageFormatter } from "../shared/messageFormatter.js";
+import { ProgressManager } from "../shared/progressManager.js";
+import { getClient } from "../utils/getClientFromConfig.js";
+import { transferDatabaseLocalToLocal, transferDatabaseLocalToRemote, transferStorageLocalToLocal, transferStorageLocalToRemote, transferUsersLocalToRemote } from "./transfer.js";
+import { deployLocalFunction } from "../functions/deployments.js";
+import { listFunctions, downloadLatestFunctionDeployment } from "../functions/methods.js";
+import pLimit from "p-limit";
+import chalk from "chalk";
+import { join } from "node:path";
+import fs from "node:fs";
+export class ComprehensiveTransfer {
+    options;
+    sourceClient;
+    targetClient;
+    sourceUsers;
+    targetUsers;
+    sourceDatabases;
+    targetDatabases;
+    sourceStorage;
+    targetStorage;
+    sourceFunctions;
+    targetFunctions;
+    limit;
+    userLimit;
+    fileLimit;
+    results;
+    startTime;
+    tempDir;
+    constructor(options) {
+        this.options = options;
+        this.sourceClient = getClient(options.sourceEndpoint, options.sourceProject, options.sourceKey);
+        this.targetClient = getClient(options.targetEndpoint, options.targetProject, options.targetKey);
+        this.sourceUsers = new Users(this.sourceClient);
+        this.targetUsers = new Users(this.targetClient);
+        this.sourceDatabases = new Databases(this.sourceClient);
+        this.targetDatabases = new Databases(this.targetClient);
+        this.sourceStorage = new Storage(this.sourceClient);
+        this.targetStorage = new Storage(this.targetClient);
+        this.sourceFunctions = new Functions(this.sourceClient);
+        this.targetFunctions = new Functions(this.targetClient);
+        const baseLimit = options.concurrencyLimit || 10;
+        this.limit = pLimit(baseLimit);
+        // Different rate limits for different operations to prevent API throttling
+        // Users: Half speed (more sensitive operations)
+        // Files: Quarter speed (most bandwidth intensive)
+        this.userLimit = pLimit(Math.max(1, Math.floor(baseLimit / 2)));
+        this.fileLimit = pLimit(Math.max(1, Math.floor(baseLimit / 4)));
+        this.results = {
+            users: { transferred: 0, skipped: 0, failed: 0 },
+            databases: { transferred: 0, skipped: 0, failed: 0 },
+            buckets: { transferred: 0, skipped: 0, failed: 0 },
+            functions: { transferred: 0, skipped: 0, failed: 0 },
+            totalTime: 0,
+        };
+        this.startTime = Date.now();
+        this.tempDir = join(process.cwd(), ".appwrite-transfer-temp");
+    }
+    async execute() {
+        try {
+            MessageFormatter.info("Starting comprehensive transfer", { prefix: "Transfer" });
+            if (this.options.dryRun) {
+                MessageFormatter.info("DRY RUN MODE - No actual changes will be made", { prefix: "Transfer" });
+            }
+            // Show rate limiting configuration
+            const baseLimit = this.options.concurrencyLimit || 10;
+            const userLimit = Math.max(1, Math.floor(baseLimit / 2));
+            const fileLimit = Math.max(1, Math.floor(baseLimit / 4));
+            MessageFormatter.info(`Rate limits: General=${baseLimit}, Users=${userLimit}, Files=${fileLimit}`, { prefix: "Transfer" });
+            // Ensure temp directory exists
+            if (!fs.existsSync(this.tempDir)) {
+                fs.mkdirSync(this.tempDir, { recursive: true });
+            }
+            // Execute transfers in the correct order
+            if (this.options.transferUsers !== false) {
+                await this.transferAllUsers();
+            }
+            if (this.options.transferDatabases !== false) {
+                await this.transferAllDatabases();
+            }
+            if (this.options.transferBuckets !== false) {
+                await this.transferAllBuckets();
+            }
+            if (this.options.transferFunctions !== false) {
+                await this.transferAllFunctions();
+            }
+            this.results.totalTime = Date.now() - this.startTime;
+            this.printSummary();
+            return this.results;
+        }
+        catch (error) {
+            MessageFormatter.error("Comprehensive transfer failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+            throw error;
+        }
+        finally {
+            // Clean up temp directory
+            if (fs.existsSync(this.tempDir)) {
+                fs.rmSync(this.tempDir, { recursive: true, force: true });
+            }
+        }
+    }
+    async transferAllUsers() {
+        MessageFormatter.info("Starting user transfer phase", { prefix: "Transfer" });
+        if (this.options.dryRun) {
+            const usersList = await this.sourceUsers.list([Query.limit(1)]);
+            MessageFormatter.info(`DRY RUN: Would transfer ${usersList.total} users`, { prefix: "Transfer" });
+            return;
+        }
+        try {
+            // Use the existing user transfer function
+            // Note: The rate limiting is handled at the API level, not per-user
+            // since user operations are already sequential in the existing implementation
+            await transferUsersLocalToRemote(this.sourceUsers, this.options.targetEndpoint, this.options.targetProject, this.options.targetKey);
+            // Get actual count for results
+            const usersList = await this.sourceUsers.list([Query.limit(1)]);
+            this.results.users.transferred = usersList.total;
+            MessageFormatter.success(`User transfer completed`, { prefix: "Transfer" });
+        }
+        catch (error) {
+            MessageFormatter.error("User transfer failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+            this.results.users.failed = 1;
+        }
+    }
+    async transferAllDatabases() {
+        MessageFormatter.info("Starting database transfer phase", { prefix: "Transfer" });
+        try {
+            const sourceDatabases = await this.sourceDatabases.list();
+            const targetDatabases = await this.targetDatabases.list();
+            if (this.options.dryRun) {
+                MessageFormatter.info(`DRY RUN: Would transfer ${sourceDatabases.databases.length} databases`, { prefix: "Transfer" });
+                return;
+            }
+            const transferTasks = sourceDatabases.databases.map(db => this.limit(async () => {
+                try {
+                    // Check if database exists in target
+                    const existingDb = targetDatabases.databases.find(tdb => tdb.$id === db.$id);
+                    if (!existingDb) {
+                        // Create database in target
+                        await this.targetDatabases.create(db.$id, db.name, db.enabled);
+                        MessageFormatter.success(`Created database: ${db.name}`, { prefix: "Transfer" });
+                    }
+                    // Transfer database content
+                    await transferDatabaseLocalToRemote(this.sourceDatabases, this.options.targetEndpoint, this.options.targetProject, this.options.targetKey, db.$id, db.$id);
+                    this.results.databases.transferred++;
+                    MessageFormatter.success(`Database ${db.name} transferred successfully`, { prefix: "Transfer" });
+                }
+                catch (error) {
+                    MessageFormatter.error(`Database ${db.name} transfer failed`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+                    this.results.databases.failed++;
+                }
+            }));
+            await Promise.all(transferTasks);
+            MessageFormatter.success("Database transfer phase completed", { prefix: "Transfer" });
+        }
+        catch (error) {
+            MessageFormatter.error("Database transfer phase failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+        }
+    }
+    async transferAllBuckets() {
+        MessageFormatter.info("Starting bucket transfer phase", { prefix: "Transfer" });
+        try {
+            const sourceBuckets = await this.sourceStorage.listBuckets();
+            const targetBuckets = await this.targetStorage.listBuckets();
+            if (this.options.dryRun) {
+                let totalFiles = 0;
+                for (const bucket of sourceBuckets.buckets) {
+                    const files = await this.sourceStorage.listFiles(bucket.$id, [Query.limit(1)]);
+                    totalFiles += files.total;
+                }
+                MessageFormatter.info(`DRY RUN: Would transfer ${sourceBuckets.buckets.length} buckets with ${totalFiles} files`, { prefix: "Transfer" });
+                return;
+            }
+            const transferTasks = sourceBuckets.buckets.map(bucket => this.limit(async () => {
+                try {
+                    // Check if bucket exists in target
+                    const existingBucket = targetBuckets.buckets.find(tb => tb.$id === bucket.$id);
+                    if (!existingBucket) {
+                        // Create bucket in target
+                        await this.targetStorage.createBucket(bucket.$id, bucket.name, bucket.$permissions, bucket.fileSecurity, bucket.enabled, bucket.maximumFileSize, bucket.allowedFileExtensions, bucket.compression, bucket.encryption, bucket.antivirus);
+                        MessageFormatter.success(`Created bucket: ${bucket.name}`, { prefix: "Transfer" });
+                    }
+                    // Transfer bucket files with enhanced validation
+                    await this.transferBucketFiles(bucket.$id, bucket.$id);
+                    this.results.buckets.transferred++;
+                    MessageFormatter.success(`Bucket ${bucket.name} transferred successfully`, { prefix: "Transfer" });
+                }
+                catch (error) {
+                    MessageFormatter.error(`Bucket ${bucket.name} transfer failed`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+                    this.results.buckets.failed++;
+                }
+            }));
+            await Promise.all(transferTasks);
+            MessageFormatter.success("Bucket transfer phase completed", { prefix: "Transfer" });
+        }
+        catch (error) {
+            MessageFormatter.error("Bucket transfer phase failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+        }
+    }
+    async transferBucketFiles(sourceBucketId, targetBucketId) {
+        let lastFileId;
+        let transferredFiles = 0;
+        while (true) {
+            const queries = [Query.limit(50)]; // Smaller batch size for better rate limiting
+            if (lastFileId) {
+                queries.push(Query.cursorAfter(lastFileId));
+            }
+            const files = await this.sourceStorage.listFiles(sourceBucketId, queries);
+            if (files.files.length === 0)
+                break;
+            // Process files with rate limiting
+            const fileTasks = files.files.map(file => this.fileLimit(async () => {
+                try {
+                    // Check if file already exists
+                    try {
+                        await this.targetStorage.getFile(targetBucketId, file.$id);
+                        MessageFormatter.info(`File ${file.name} already exists, skipping`, { prefix: "Transfer" });
+                        return;
+                    }
+                    catch (error) {
+                        // File doesn't exist, proceed with transfer
+                    }
+                    // Download file with validation
+                    const fileData = await this.validateAndDownloadFile(sourceBucketId, file.$id);
+                    if (!fileData) {
+                        MessageFormatter.warning(`File ${file.name} failed validation, skipping`, { prefix: "Transfer" });
+                        return;
+                    }
+                    // Upload file to target
+                    const fileToCreate = InputFile.fromBuffer(new Uint8Array(fileData), file.name);
+                    await this.targetStorage.createFile(targetBucketId, file.$id, fileToCreate, file.$permissions);
+                    transferredFiles++;
+                    MessageFormatter.success(`Transferred file: ${file.name}`, { prefix: "Transfer" });
+                }
+                catch (error) {
+                    MessageFormatter.error(`Failed to transfer file ${file.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+                }
+            }));
+            await Promise.all(fileTasks);
+            if (files.files.length < 50)
+                break;
+            lastFileId = files.files[files.files.length - 1].$id;
+        }
+        MessageFormatter.info(`Transferred ${transferredFiles} files from bucket ${sourceBucketId}`, { prefix: "Transfer" });
+    }
+    async validateAndDownloadFile(bucketId, fileId) {
+        let attempts = 3;
+        while (attempts > 0) {
+            try {
+                const fileData = await this.sourceStorage.getFileDownload(bucketId, fileId);
+                // Basic validation - ensure file is not empty and not too large
+                if (fileData.byteLength === 0) {
+                    MessageFormatter.warning(`File ${fileId} is empty`, { prefix: "Transfer" });
+                    return null;
+                }
+                if (fileData.byteLength > 50 * 1024 * 1024) { // 50MB limit
+                    MessageFormatter.warning(`File ${fileId} is too large (${fileData.byteLength} bytes)`, { prefix: "Transfer" });
+                    return null;
+                }
+                return fileData;
+            }
+            catch (error) {
+                attempts--;
+                MessageFormatter.warning(`Error downloading file ${fileId}, attempts left: ${attempts}`, { prefix: "Transfer" });
+                if (attempts === 0) {
+                    MessageFormatter.error(`Failed to download file ${fileId} after all attempts`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+                    return null;
+                }
+                // Wait before retry
+                await new Promise(resolve => setTimeout(resolve, 1000 * (4 - attempts)));
+            }
+        }
+        return null;
+    }
+    async transferAllFunctions() {
+        MessageFormatter.info("Starting function transfer phase", { prefix: "Transfer" });
+        try {
+            const sourceFunctions = await listFunctions(this.sourceClient, [Query.limit(1000)]);
+            const targetFunctions = await listFunctions(this.targetClient, [Query.limit(1000)]);
+            if (this.options.dryRun) {
+                MessageFormatter.info(`DRY RUN: Would transfer ${sourceFunctions.functions.length} functions`, { prefix: "Transfer" });
+                return;
+            }
+            const transferTasks = sourceFunctions.functions.map(func => this.limit(async () => {
+                try {
+                    // Check if function exists in target
+                    const existingFunc = targetFunctions.functions.find(tf => tf.$id === func.$id);
+                    if (existingFunc) {
+                        MessageFormatter.info(`Function ${func.name} already exists, skipping creation`, { prefix: "Transfer" });
+                        this.results.functions.skipped++;
+                        return;
+                    }
+                    // Download function from source
+                    const functionPath = await this.downloadFunction(func);
+                    if (!functionPath) {
+                        MessageFormatter.error(`Failed to download function ${func.name}`, undefined, { prefix: "Transfer" });
+                        this.results.functions.failed++;
+                        return;
+                    }
+                    // Deploy function to target
+                    const functionConfig = {
+                        $id: func.$id,
+                        name: func.name,
+                        runtime: func.runtime,
+                        execute: func.execute,
+                        events: func.events,
+                        enabled: func.enabled,
+                        logging: func.logging,
+                        entrypoint: func.entrypoint,
+                        commands: func.commands,
+                        scopes: func.scopes,
+                        timeout: func.timeout,
+                        schedule: func.schedule,
+                        installationId: func.installationId,
+                        providerRepositoryId: func.providerRepositoryId,
+                        providerBranch: func.providerBranch,
+                        providerSilentMode: func.providerSilentMode,
+                        providerRootDirectory: func.providerRootDirectory,
+                        specification: func.specification,
+                        dirPath: functionPath,
+                    };
+                    await deployLocalFunction(this.targetClient, func.name, functionConfig);
+                    this.results.functions.transferred++;
+                    MessageFormatter.success(`Function ${func.name} transferred successfully`, { prefix: "Transfer" });
+                }
+                catch (error) {
+                    MessageFormatter.error(`Function ${func.name} transfer failed`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+                    this.results.functions.failed++;
+                }
+            }));
+            await Promise.all(transferTasks);
+            MessageFormatter.success("Function transfer phase completed", { prefix: "Transfer" });
+        }
+        catch (error) {
+            MessageFormatter.error("Function transfer phase failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+        }
+    }
+    async downloadFunction(func) {
+        try {
+            const { path } = await downloadLatestFunctionDeployment(this.sourceClient, func.$id, this.tempDir);
+            return path;
+        }
+        catch (error) {
+            MessageFormatter.error(`Failed to download function ${func.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+            return null;
+        }
+    }
+    printSummary() {
+        const duration = Math.round((Date.now() - this.startTime) / 1000);
+        MessageFormatter.info("=== COMPREHENSIVE TRANSFER SUMMARY ===", { prefix: "Transfer" });
+        MessageFormatter.info(`Total Time: ${duration}s`, { prefix: "Transfer" });
+        MessageFormatter.info(`Users: ${this.results.users.transferred} transferred, ${this.results.users.skipped} skipped, ${this.results.users.failed} failed`, { prefix: "Transfer" });
+        MessageFormatter.info(`Databases: ${this.results.databases.transferred} transferred, ${this.results.databases.skipped} skipped, ${this.results.databases.failed} failed`, { prefix: "Transfer" });
+        MessageFormatter.info(`Buckets: ${this.results.buckets.transferred} transferred, ${this.results.buckets.skipped} skipped, ${this.results.buckets.failed} failed`, { prefix: "Transfer" });
+        MessageFormatter.info(`Functions: ${this.results.functions.transferred} transferred, ${this.results.functions.skipped} skipped, ${this.results.functions.failed} failed`, { prefix: "Transfer" });
+        const totalTransferred = this.results.users.transferred + this.results.databases.transferred + this.results.buckets.transferred + this.results.functions.transferred;
+        const totalFailed = this.results.users.failed + this.results.databases.failed + this.results.buckets.failed + this.results.functions.failed;
+        if (totalFailed === 0) {
+            MessageFormatter.success(`All ${totalTransferred} items transferred successfully!`, { prefix: "Transfer" });
+        }
+        else {
+            MessageFormatter.warning(`${totalTransferred} items transferred, ${totalFailed} failed`, { prefix: "Transfer" });
+        }
+    }
+}

package/dist/migrations/yaml/YamlImportConfigLoader.d.ts

@@ -195,8 +195,8 @@ export declare const YamlImportConfigSchema: z.ZodObject<{
         }>>;
     }, "strip", z.ZodTypeAny, {
         batchSize: number;
-        skipValidation: boolean;
         dryRun: boolean;
+        skipValidation: boolean;
         continueOnError: boolean;
         updateMapping?: {
             targetField: string;
@@ -204,8 +204,8 @@ export declare const YamlImportConfigSchema: z.ZodObject<{
         } | undefined;
     }, {
         batchSize?: number | undefined;
-        skipValidation?: boolean | undefined;
         dryRun?: boolean | undefined;
+        skipValidation?: boolean | undefined;
         continueOnError?: boolean | undefined;
         updateMapping?: {
             targetField: string;
@@ -215,8 +215,8 @@ export declare const YamlImportConfigSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     options: {
         batchSize: number;
-        skipValidation: boolean;
         dryRun: boolean;
+        skipValidation: boolean;
         continueOnError: boolean;
         updateMapping?: {
             targetField: string;
@@ -304,8 +304,8 @@ export declare const YamlImportConfigSchema: z.ZodObject<{
     };
     options?: {
         batchSize?: number | undefined;
-        skipValidation?: boolean | undefined;
         dryRun?: boolean | undefined;
+        skipValidation?: boolean | undefined;
         continueOnError?: boolean | undefined;
         updateMapping?: {
             targetField: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "appwrite-utils-cli",
   "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/interactiveCLI.ts

@@ -15,6 +15,7 @@ import {
 } from "node-appwrite";
 import { getClient } from "./utils/getClientFromConfig.js";
 import type { TransferOptions } from "./migrations/transfer.js";
+import { ComprehensiveTransfer, type ComprehensiveTransferOptions } from "./migrations/comprehensiveTransfer.js";
 import {
   AppwriteFunctionSchema,
   parseAttribute,
@@ -61,6 +62,7 @@ enum CHOICES {
   SYNC_DB = "⬆️ Push local config to Appwrite",
   SYNCHRONIZE_CONFIGURATIONS = "🔄 Synchronize configurations - Pull from Appwrite and write to local config",
   TRANSFER_DATA = "📦 Transfer data",
+  COMPREHENSIVE_TRANSFER = "🚀 Comprehensive transfer (users → databases → buckets → functions)",
   BACKUP_DATABASE = "💾 Backup database",
   WIPE_DATABASE = "🧹 Wipe database",
   WIPE_COLLECTIONS = "🧹 Wipe collections",
@@ -145,6 +147,9 @@ export class InteractiveCLI {
           await this.initControllerIfNeeded();
           await this.transferData();
           break;
+        case CHOICES.COMPREHENSIVE_TRANSFER:
+          await this.comprehensiveTransfer();
+          break;
         case CHOICES.BACKUP_DATABASE:
           await this.initControllerIfNeeded();
           await this.backupDatabase();
@@ -1903,12 +1908,12 @@ export class InteractiveCLI {
   }
 
   private async reloadConfig(): Promise<void> {
-    console.log(chalk.yellow("Reloading configuration files..."));
+    MessageFormatter.progress("Reloading configuration files...", { prefix: "Config" });
     try {
       await this.controller!.reloadConfig();
-      console.log(chalk.green("Configuration files reloaded successfully."));
+      MessageFormatter.success("Configuration files reloaded successfully", { prefix: "Config" });
     } catch (error) {
-      console.error(chalk.red("Error reloading configuration files:"), error);
+      MessageFormatter.error("Failed to reload configuration files", error instanceof Error ? error : new Error(String(error)), { prefix: "Config" });
     }
   }
 
@@ -1979,7 +1984,6 @@ export class InteractiveCLI {
     try {
       // Check for YAML config first
       const yamlConfigPath = findYamlConfig(this.currentDir);
-      console.log(`DEBUG: YAML config search from ${this.currentDir}, found: ${yamlConfigPath}`);
       if (yamlConfigPath) {
         this.isUsingTypeScriptConfig = false;
         MessageFormatter.info("Using YAML configuration", { prefix: "Config" });
@@ -2043,4 +2047,175 @@ export class InteractiveCLI {
       MessageFormatter.error("Migration failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Migration" });
     }
   }
+
+  private async comprehensiveTransfer(): Promise<void> {
+    MessageFormatter.info("Starting comprehensive transfer configuration...", { prefix: "Transfer" });
+
+    try {
+      // Get source configuration
+      const sourceConfig = await inquirer.prompt([
+        {
+          type: "input",
+          name: "sourceEndpoint",
+          message: "Enter the source Appwrite endpoint:",
+          validate: (input) => input.trim() !== "" || "Endpoint cannot be empty",
+        },
+        {
+          type: "input",
+          name: "sourceProject",
+          message: "Enter the source project ID:",
+          validate: (input) => input.trim() !== "" || "Project ID cannot be empty",
+        },
+        {
+          type: "password",
+          name: "sourceKey",
+          message: "Enter the source API key:",
+          validate: (input) => input.trim() !== "" || "API key cannot be empty",
+        },
+      ]);
+
+      // Get target configuration
+      const targetConfig = await inquirer.prompt([
+        {
+          type: "input",
+          name: "targetEndpoint",
+          message: "Enter the target Appwrite endpoint:",
+          validate: (input) => input.trim() !== "" || "Endpoint cannot be empty",
+        },
+        {
+          type: "input",
+          name: "targetProject",
+          message: "Enter the target project ID:",
+          validate: (input) => input.trim() !== "" || "Project ID cannot be empty",
+        },
+        {
+          type: "password",
+          name: "targetKey",
+          message: "Enter the target API key:",
+          validate: (input) => input.trim() !== "" || "API key cannot be empty",
+        },
+      ]);
+
+      // Get transfer options
+      const transferOptions = await inquirer.prompt([
+        {
+          type: "checkbox",
+          name: "transferTypes",
+          message: "Select what to transfer:",
+          choices: [
+            { name: "👥 Users", value: "users", checked: true },
+            { name: "🗄️ Databases", value: "databases", checked: true },
+            { name: "📦 Storage Buckets", value: "buckets", checked: true },
+            { name: "⚡ Functions", value: "functions", checked: true },
+          ],
+          validate: (input) => input.length > 0 || "Select at least one transfer type",
+        },
+        {
+          type: "list",
+          name: "concurrencyLimit",
+          message: "Select concurrency limit:",
+          choices: [
+            { name: "5 (Conservative) - Users: 2, Files: 1", value: 5 },
+            { name: "10 (Balanced) - Users: 5, Files: 2", value: 10 },
+            { name: "15 - Users: 7, Files: 3", value: 15 },
+            { name: "20 - Users: 10, Files: 5", value: 20 },
+            { name: "25 - Users: 12, Files: 6", value: 25 },
+            { name: "30 - Users: 15, Files: 7", value: 30 },
+            { name: "35 - Users: 17, Files: 8", value: 35 },
+            { name: "40 - Users: 20, Files: 10", value: 40 },
+            { name: "45 - Users: 22, Files: 11", value: 45 },
+            { name: "50 - Users: 25, Files: 12", value: 50 },
+            { name: "55 - Users: 27, Files: 13", value: 55 },
+            { name: "60 - Users: 30, Files: 15", value: 60 },
+            { name: "65 - Users: 32, Files: 16", value: 65 },
+            { name: "70 - Users: 35, Files: 17", value: 70 },
+            { name: "75 - Users: 37, Files: 18", value: 75 },
+            { name: "80 - Users: 40, Files: 20", value: 80 },
+            { name: "85 - Users: 42, Files: 21", value: 85 },
+            { name: "90 - Users: 45, Files: 22", value: 90 },
+            { name: "95 - Users: 47, Files: 23", value: 95 },
+            { name: "100 (Aggressive) - Users: 50, Files: 25", value: 100 },
+          ],
+          default: 10,
+        },
+        {
+          type: "confirm",
+          name: "dryRun",
+          message: "Run in dry-run mode (no actual changes)?",
+          default: false,
+        },
+      ]);
+
+      // Confirmation
+      const { confirmed } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "confirmed",
+          message: `Are you sure you want to ${transferOptions.dryRun ? "dry-run" : "perform"} comprehensive transfer from ${sourceConfig.sourceEndpoint} to ${targetConfig.targetEndpoint}?`,
+          default: false,
+        },
+      ]);
+
+      if (!confirmed) {
+        MessageFormatter.info("Transfer cancelled by user", { prefix: "Transfer" });
+        return;
+      }
+
+      // Important password warning
+      if (transferOptions.transferTypes.includes("users") && !transferOptions.dryRun) {
+        MessageFormatter.warning("IMPORTANT: User passwords cannot be transferred due to Appwrite security limitations.", { prefix: "Transfer" });
+        MessageFormatter.warning("Users will need to reset their passwords after transfer.", { prefix: "Transfer" });
+        
+        const { continueWithUsers } = await inquirer.prompt([
+          {
+            type: "confirm",
+            name: "continueWithUsers",
+            message: "Continue with user transfer knowing passwords will be reset?",
+            default: false,
+          },
+        ]);
+
+        if (!continueWithUsers) {
+          // Remove users from transfer types
+          transferOptions.transferTypes = transferOptions.transferTypes.filter((type: string) => type !== "users");
+          if (transferOptions.transferTypes.length === 0) {
+            MessageFormatter.info("No transfer types selected, cancelling", { prefix: "Transfer" });
+            return;
+          }
+        }
+      }
+
+      // Execute comprehensive transfer
+      const comprehensiveTransferOptions: ComprehensiveTransferOptions = {
+        sourceEndpoint: sourceConfig.sourceEndpoint,
+        sourceProject: sourceConfig.sourceProject,
+        sourceKey: sourceConfig.sourceKey,
+        targetEndpoint: targetConfig.targetEndpoint,
+        targetProject: targetConfig.targetProject,
+        targetKey: targetConfig.targetKey,
+        transferUsers: transferOptions.transferTypes.includes("users"),
+        transferDatabases: transferOptions.transferTypes.includes("databases"),
+        transferBuckets: transferOptions.transferTypes.includes("buckets"),
+        transferFunctions: transferOptions.transferTypes.includes("functions"),
+        concurrencyLimit: transferOptions.concurrencyLimit,
+        dryRun: transferOptions.dryRun,
+      };
+
+      const transfer = new ComprehensiveTransfer(comprehensiveTransferOptions);
+      const results = await transfer.execute();
+
+      // Display results
+      if (transferOptions.dryRun) {
+        MessageFormatter.success("Dry run completed successfully!", { prefix: "Transfer" });
+      } else {
+        MessageFormatter.success("Comprehensive transfer completed!", { prefix: "Transfer" });
+        if (transferOptions.transferTypes.includes("users") && results.users.transferred > 0) {
+          MessageFormatter.info("Remember to notify users about password reset requirements", { prefix: "Transfer" });
+        }
+      }
+
+    } catch (error) {
+      MessageFormatter.error("Comprehensive transfer failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
+    }
+  }
 }