appwrite-utils-cli 1.7.9 → 1.8.2

package/src/main.ts

@@ -21,16 +21,26 @@ import type { SyncSelectionSummary, DatabaseSelection, BucketSelection } from ".
 import path from "path";
 import fs from "fs";
 import { createRequire } from "node:module";
-import { loadAppwriteProjectConfig, findAppwriteProjectConfig, projectConfigToAppwriteConfig } from "./utils/projectConfig.js";
-import { hasSessionAuth, getAvailableSessions, getAuthenticationStatus } from "./utils/sessionAuth.js";
-import { findYamlConfig, loadYamlConfigWithSession } from "./config/yamlConfig.js";
+import {
+  loadAppwriteProjectConfig,
+  findAppwriteProjectConfig,
+  projectConfigToAppwriteConfig,
+} from "./utils/projectConfig.js";
+import {
+  hasSessionAuth,
+  getAvailableSessions,
+  getAuthenticationStatus,
+} from "./utils/sessionAuth.js";
+import {
+  findYamlConfig,
+  loadYamlConfigWithSession,
+} from "./config/yamlConfig.js";
 
 const require = createRequire(import.meta.url);
 if (!(globalThis as any).require) {
   (globalThis as any).require = require;
 }
 
-
 interface CliOptions {
   config?: string;
   it?: boolean;
@@ -42,7 +52,7 @@ interface CliOptions {
   generate?: boolean;
   import?: boolean;
   backup?: boolean;
-  backupFormat?: 'json' | 'zip';
+  backupFormat?: "json" | "zip";
   comprehensiveBackup?: boolean;
   trackingDatabaseId?: string;
   parallelDownloads?: number;
@@ -170,15 +180,15 @@ async function performEnhancedSync(
     const allowNewOnly = !syncExisting;
 
     // Select databases
-    const selectedDatabaseIds = await SelectionDialogs.selectDatabases(
-      availableDatabases,
-      configuredDatabases,
-      {
-        showSelectAll: true,
-        allowNewOnly,
-        defaultSelected: syncExisting ? configuredDatabases.map(db => db.$id) : []
-      }
-    );
+    const selectedDatabaseIds = await SelectionDialogs.selectDatabases(
+      availableDatabases,
+      configuredDatabases,
+      {
+        showSelectAll: false,
+        allowNewOnly,
+        defaultSelected: []
+      }
+    );
 
     if (selectedDatabaseIds.length === 0) {
       MessageFormatter.warning("No databases selected for sync", { prefix: "Sync" });
@@ -203,17 +213,17 @@ async function performEnhancedSync(
       const configuredTables = controller.config.collections || [];
 
       // Select tables for this database
-      const selectedTableIds = await SelectionDialogs.selectTablesForDatabase(
-        databaseId,
-        database.name,
-        availableTables,
-        configuredTables,
-        {
-          showSelectAll: true,
-          allowNewOnly,
-          defaultSelected: syncExisting ? configuredTables.map((t: any) => t.$id) : []
-        }
-      );
+      const selectedTableIds = await SelectionDialogs.selectTablesForDatabase(
+        databaseId,
+        database.name,
+        availableTables,
+        configuredTables,
+        {
+          showSelectAll: false,
+          allowNewOnly,
+          defaultSelected: []
+        }
+      );
 
       tableSelectionsMap.set(databaseId, selectedTableIds);
 
@@ -236,17 +246,17 @@ async function performEnhancedSync(
         // you'd fetch this from the Appwrite API
         const availableBuckets = configuredBuckets; // Placeholder
 
-        selectedBucketIds = await SelectionDialogs.selectBucketsForDatabases(
-          selectedDatabaseIds,
-          availableBuckets,
-          configuredBuckets,
-          {
-            showSelectAll: true,
-            allowNewOnly: parsedArgv.selectBuckets ? false : allowNewOnly,
-            groupByDatabase: true,
-            defaultSelected: syncExisting ? configuredBuckets.map(b => b.$id) : []
-          }
-        );
+        selectedBucketIds = await SelectionDialogs.selectBucketsForDatabases(
+          selectedDatabaseIds,
+          availableBuckets,
+          configuredBuckets,
+          {
+            showSelectAll: false,
+            allowNewOnly: parsedArgv.selectBuckets ? false : allowNewOnly,
+            groupByDatabase: true,
+            defaultSelected: []
+          }
+        );
       } catch (error) {
         MessageFormatter.warning("Could not fetch storage buckets", { prefix: "Sync" });
         logger.warn("Failed to fetch buckets during sync", { error });
@@ -303,7 +313,10 @@ async function performEnhancedSync(
  * - allowed: boolean indicating if migration should proceed
  * - reason: string explaining why migration was blocked (if not allowed)
  */
-function checkMigrationConditions(configPath: string): { allowed: boolean; reason?: string } {
+function checkMigrationConditions(configPath: string): {
+  allowed: boolean;
+  reason?: string;
+} {
   const collectionsPath = path.join(configPath, "collections");
   const tablesPath = path.join(configPath, "tables");
 
@@ -311,32 +324,34 @@ function checkMigrationConditions(configPath: string): { allowed: boolean; reaso
   if (!fs.existsSync(collectionsPath)) {
     return {
       allowed: false,
-      reason: "No collections/ folder found. Migration requires existing collections to migrate."
+      reason:
+        "No collections/ folder found. Migration requires existing collections to migrate.",
     };
   }
 
   // Check if collections/ folder has YAML files
-  const collectionFiles = fs.readdirSync(collectionsPath).filter(file =>
-    file.endsWith(".yaml") || file.endsWith(".yml")
-  );
+  const collectionFiles = fs
+    .readdirSync(collectionsPath)
+    .filter((file) => file.endsWith(".yaml") || file.endsWith(".yml"));
 
   if (collectionFiles.length === 0) {
     return {
       allowed: false,
-      reason: "No YAML files found in collections/ folder. Migration requires existing collection YAML files."
+      reason:
+        "No YAML files found in collections/ folder. Migration requires existing collection YAML files.",
     };
   }
 
   // Check if tables/ folder exists and has YAML files
   if (fs.existsSync(tablesPath)) {
-    const tableFiles = fs.readdirSync(tablesPath).filter(file =>
-      file.endsWith(".yaml") || file.endsWith(".yml")
-    );
+    const tableFiles = fs
+      .readdirSync(tablesPath)
+      .filter((file) => file.endsWith(".yaml") || file.endsWith(".yml"));
 
     if (tableFiles.length > 0) {
       return {
         allowed: false,
-        reason: `Tables folder already exists with ${tableFiles.length} YAML file(s). Migration appears to have already been completed.`
+        reason: `Tables folder already exists with ${tableFiles.length} YAML file(s). Migration appears to have already been completed.`,
       };
     }
   }
@@ -357,12 +372,14 @@ const argv = yargs(hideBin(process.argv))
   })
   .option("dbIds", {
     type: "string",
-    description: "Comma-separated list of database IDs to target (e.g., 'db1,db2,db3')",
+    description:
+      "Comma-separated list of database IDs to target (e.g., 'db1,db2,db3')",
   })
   .option("collectionIds", {
     alias: ["collIds", "tableIds", "tables"],
     type: "string",
-    description: "Comma-separated list of collection/table IDs to target (e.g., 'users,posts')",
+    description:
+      "Comma-separated list of collection/table IDs to target (e.g., 'users,posts')",
   })
   .option("bucketIds", {
     type: "string",
@@ -384,11 +401,13 @@ const argv = yargs(hideBin(process.argv))
   })
   .option("generate", {
     type: "boolean",
-    description: "Generate TypeScript schemas and types from your Appwrite database schemas",
+    description:
+      "Generate TypeScript schemas and types from your Appwrite database schemas",
   })
   .option("import", {
     type: "boolean",
-    description: "Import data from importData/ directory into your Appwrite databases",
+    description:
+      "Import data from importData/ directory into your Appwrite databases",
   })
   .option("backup", {
     type: "boolean",
@@ -407,21 +426,25 @@ const argv = yargs(hideBin(process.argv))
   .option("comprehensiveBackup", {
     alias: ["comprehensive", "backup-all"],
     type: "boolean",
-    description: "🚀 Create comprehensive backup of ALL databases and ALL storage buckets",
+    description:
+      "🚀 Create comprehensive backup of ALL databases and ALL storage buckets",
   })
   .option("trackingDatabaseId", {
     alias: ["tracking-db"],
     type: "string",
-    description: "Database ID to use for centralized backup tracking (interactive prompt if not specified)",
+    description:
+      "Database ID to use for centralized backup tracking (interactive prompt if not specified)",
   })
   .option("parallelDownloads", {
     type: "number",
     default: 10,
-    description: "Number of parallel file downloads for bucket backups (default: 10)",
+    description:
+      "Number of parallel file downloads for bucket backups (default: 10)",
   })
   .option("writeData", {
     type: "boolean",
-    description: "Output converted import data to files for validation before importing",
+    description:
+      "Output converted import data to files for validation before importing",
   })
   .option("push", {
     type: "boolean",
@@ -456,7 +479,8 @@ const argv = yargs(hideBin(process.argv))
   })
   .option("transfer", {
     type: "boolean",
-    description: "Transfer documents and files between databases, collections, or projects",
+    description:
+      "Transfer documents and files between databases, collections, or projects",
   })
   .option("fromDbId", {
     alias: ["fromDb", "sourceDbId", "sourceDb"],
@@ -500,7 +524,8 @@ const argv = yargs(hideBin(process.argv))
   })
   .option("setup", {
     type: "boolean",
-    description: "Initialize project with configuration files and directory structure",
+    description:
+      "Initialize project with configuration files and directory structure",
   })
   .option("updateFunctionSpec", {
     type: "boolean",
@@ -527,27 +552,32 @@ const argv = yargs(hideBin(process.argv))
   .option("migrateConfig", {
     alias: ["migrate"],
     type: "boolean",
-    description: "Migrate appwriteConfig.ts to .appwrite structure with YAML configuration",
+    description:
+      "Migrate appwriteConfig.ts to .appwrite structure with YAML configuration",
   })
   .option("generateConstants", {
     alias: ["constants"],
-    type: "boolean", 
-    description: "Generate cross-language constants file with database, collection, bucket, and function IDs",
+    type: "boolean",
+    description:
+      "Generate cross-language constants file with database, collection, bucket, and function IDs",
   })
   .option("constantsLanguages", {
     type: "string",
-    description: "Comma-separated list of languages for constants (typescript,javascript,python,php,dart,json,env)",
+    description:
+      "Comma-separated list of languages for constants (typescript,javascript,python,php,dart,json,env)",
     default: "typescript",
   })
   .option("constantsOutput", {
     type: "string",
-    description: "Output directory for generated constants files (default: config-folder/constants)",
+    description:
+      "Output directory for generated constants files (default: config-folder/constants)",
     default: "auto",
   })
   .option("migrateCollectionsToTables", {
     alias: ["migrate-collections"],
     type: "boolean",
-    description: "Migrate collections to tables format for TablesDB API compatibility",
+    description:
+      "Migrate collections to tables format for TablesDB API compatibility",
   })
   .option("useSession", {
     alias: ["session"],
@@ -563,7 +593,7 @@ const argv = yargs(hideBin(process.argv))
 async function main() {
   const startTime = Date.now();
   const operationStats: Record<string, number> = {};
-  
+
   // Early session detection for better user guidance
   const availableSessions = getAvailableSessions();
   let hasAnyValidSessions = availableSessions.length > 0;
@@ -576,17 +606,43 @@ async function main() {
     let directConfig: any = undefined;
 
     // Show authentication status on startup if no config provided
-    if (!argv.config && !argv.endpoint && !argv.projectId && !argv.apiKey && !argv.useSession && !argv.sessionCookie) {
+    if (
+      !argv.config &&
+      !argv.endpoint &&
+      !argv.projectId &&
+      !argv.apiKey &&
+      !argv.useSession &&
+      !argv.sessionCookie
+    ) {
       if (hasAnyValidSessions) {
-        MessageFormatter.info(`Found ${availableSessions.length} available session(s)`, { prefix: "Auth" });
-        availableSessions.forEach(session => {
-          MessageFormatter.info(`  \u2022 ${session.projectId} (${session.email || 'unknown'}) at ${session.endpoint}`, { prefix: "Auth" });
+        MessageFormatter.info(
+          `Found ${availableSessions.length} available session(s)`,
+          { prefix: "Auth" }
+        );
+        availableSessions.forEach((session) => {
+          MessageFormatter.info(
+            `  \u2022 ${session.projectId} (${session.email || "unknown"}) at ${
+              session.endpoint
+            }`,
+            { prefix: "Auth" }
+          );
         });
-        MessageFormatter.info("Use --session to enable session authentication", { prefix: "Auth" });
+        MessageFormatter.info(
+          "Use --session to enable session authentication",
+          { prefix: "Auth" }
+        );
       } else {
-        MessageFormatter.info("No active Appwrite sessions found", { prefix: "Auth" });
-        MessageFormatter.info("\u2022 Run 'appwrite login' to authenticate with session", { prefix: "Auth" });
-        MessageFormatter.info("\u2022 Or provide --apiKey for API key authentication", { prefix: "Auth" });
+        MessageFormatter.info("No active Appwrite sessions found", {
+          prefix: "Auth",
+        });
+        MessageFormatter.info(
+          "\u2022 Run 'appwrite login' to authenticate with session",
+          { prefix: "Auth" }
+        );
+        MessageFormatter.info(
+          "\u2022 Or provide --apiKey for API key authentication",
+          { prefix: "Auth" }
+        );
       }
     }
 
@@ -596,12 +652,21 @@ async function main() {
       const projectConfig = loadAppwriteProjectConfig(projectConfigPath);
       if (projectConfig) {
         directConfig = projectConfigToAppwriteConfig(projectConfig);
-        MessageFormatter.info(`Loaded project configuration from ${projectConfigPath}`, { prefix: "CLI" });
+        MessageFormatter.info(
+          `Loaded project configuration from ${projectConfigPath}`,
+          { prefix: "CLI" }
+        );
       }
     }
 
     // Priority 2: CLI arguments override project config
-    if (argv.endpoint || argv.projectId || argv.apiKey || argv.useSession || argv.sessionCookie) {
+    if (
+      argv.endpoint ||
+      argv.projectId ||
+      argv.apiKey ||
+      argv.useSession ||
+      argv.sessionCookie
+    ) {
       directConfig = {
         ...directConfig,
         appwriteEndpoint: argv.endpoint || directConfig?.appwriteEndpoint,
@@ -614,31 +679,64 @@ async function main() {
     let sessionAuthAvailable = false;
 
     if (directConfig?.appwriteEndpoint && directConfig?.appwriteProject) {
-      sessionAuthAvailable = hasSessionAuth(directConfig.appwriteEndpoint, directConfig.appwriteProject);
+      sessionAuthAvailable = hasSessionAuth(
+        directConfig.appwriteEndpoint,
+        directConfig.appwriteProject
+      );
     }
 
     if (argv.useSession || argv.sessionCookie) {
       if (argv.sessionCookie) {
         // Explicit session cookie provided
-        MessageFormatter.info("Using explicit session cookie for authentication", { prefix: "Auth" });
+        MessageFormatter.info(
+          "Using explicit session cookie for authentication",
+          { prefix: "Auth" }
+        );
       } else if (sessionAuthAvailable) {
-        MessageFormatter.info("Session authentication detected and will be used", { prefix: "Auth" });
+        MessageFormatter.info(
+          "Session authentication detected and will be used",
+          { prefix: "Auth" }
+        );
       } else {
-        MessageFormatter.warning("Session authentication requested but no valid session found", { prefix: "Auth" });
+        MessageFormatter.warning(
+          "Session authentication requested but no valid session found",
+          { prefix: "Auth" }
+        );
         const availableSessions = getAvailableSessions();
         if (availableSessions.length > 0) {
-          MessageFormatter.info(`Available sessions: ${availableSessions.map(s => `${s.projectId} (${s.email || 'unknown'})`).join(", ")}`, { prefix: "Auth" });
-          MessageFormatter.info("Use --session flag to enable session authentication", { prefix: "Auth" });
+          MessageFormatter.info(
+            `Available sessions: ${availableSessions
+              .map((s) => `${s.projectId} (${s.email || "unknown"})`)
+              .join(", ")}`,
+            { prefix: "Auth" }
+          );
+          MessageFormatter.info(
+            "Use --session flag to enable session authentication",
+            { prefix: "Auth" }
+          );
         } else {
-          MessageFormatter.warning("No Appwrite CLI sessions found. Please run 'appwrite login' first.", { prefix: "Auth" });
+          MessageFormatter.warning(
+            "No Appwrite CLI sessions found. Please run 'appwrite login' first.",
+            { prefix: "Auth" }
+          );
         }
-        MessageFormatter.error("Session authentication requested but not available", undefined, { prefix: "Auth" });
+        MessageFormatter.error(
+          "Session authentication requested but not available",
+          undefined,
+          { prefix: "Auth" }
+        );
         return; // Exit early if session auth was requested but not available
       }
     } else if (sessionAuthAvailable && !argv.apiKey) {
       // Auto-detect session authentication when no API key is provided
-      MessageFormatter.info("Session authentication detected - no API key required", { prefix: "Auth" });
-      MessageFormatter.info("Use --session flag to explicitly enable session authentication", { prefix: "Auth" });
+      MessageFormatter.info(
+        "Session authentication detected - no API key required",
+        { prefix: "Auth" }
+      );
+      MessageFormatter.info(
+        "Use --session flag to explicitly enable session authentication",
+        { prefix: "Auth" }
+      );
     }
 
     // Enhanced session authentication support:
@@ -647,22 +745,40 @@ async function main() {
     // 3. Auto-detect session authentication when possible
     let finalDirectConfig = directConfig;
 
-    if ((argv.useSession || argv.sessionCookie) &&
-        (!directConfig || !directConfig.appwriteEndpoint || !directConfig.appwriteProject)) {
+    if (
+      (argv.useSession || argv.sessionCookie) &&
+      (!directConfig ||
+        !directConfig.appwriteEndpoint ||
+        !directConfig.appwriteProject)
+    ) {
       // Don't pass incomplete directConfig - let UtilsController load YAML config normally
       finalDirectConfig = null;
-    } else if (finalDirectConfig && !finalDirectConfig.appwriteKey && !argv.useSession && !argv.sessionCookie) {
+    } else if (
+      finalDirectConfig &&
+      !finalDirectConfig.appwriteKey &&
+      !argv.useSession &&
+      !argv.sessionCookie
+    ) {
       // Auto-detect session authentication when no API key provided
       if (sessionAuthAvailable) {
-        MessageFormatter.info("No API key provided, but session authentication is available", { prefix: "Auth" });
-        MessageFormatter.info("Automatically using session authentication (add --session to suppress this message)", { prefix: "Auth" });
+        MessageFormatter.info(
+          "No API key provided, but session authentication is available",
+          { prefix: "Auth" }
+        );
+        MessageFormatter.info(
+          "Automatically using session authentication (add --session to suppress this message)",
+          { prefix: "Auth" }
+        );
         // Implicitly enable session authentication
         argv.useSession = true;
       }
     }
 
     // Create controller with session authentication support using singleton
-    const controller = UtilsController.getInstance(process.cwd(), finalDirectConfig);
+    const controller = UtilsController.getInstance(
+      process.cwd(),
+      finalDirectConfig
+    );
 
     // Pass session authentication options to the controller
     const initOptions: any = {};
@@ -687,43 +803,57 @@ async function main() {
     }
 
     if (argv.generateConstants) {
-      const { ConstantsGenerator } = await import("./utils/constantsGenerator.js");
-      type SupportedLanguage = import("./utils/constantsGenerator.js").SupportedLanguage;
-      
+      const { ConstantsGenerator } = await import(
+        "./utils/constantsGenerator.js"
+      );
+      type SupportedLanguage =
+        import("./utils/constantsGenerator.js").SupportedLanguage;
+
       if (!controller.config) {
-        MessageFormatter.error("No Appwrite configuration found", undefined, { prefix: "Constants" });
+        MessageFormatter.error("No Appwrite configuration found", undefined, {
+          prefix: "Constants",
+        });
         return;
       }
 
-      const languages = argv.constantsLanguages!.split(",").map(l => l.trim()) as SupportedLanguage[];
-      
+      const languages = argv
+        .constantsLanguages!.split(",")
+        .map((l) => l.trim()) as SupportedLanguage[];
+
       // Determine output directory - use config folder/constants by default, or custom path if specified
       let outputDir: string;
       if (argv.constantsOutput === "auto") {
         // Default case: use config directory + constants, fallback to current directory
         const configPath = controller.getAppwriteFolderPath();
-        outputDir = configPath 
+        outputDir = configPath
           ? path.join(configPath, "constants")
           : path.join(process.cwd(), "constants");
       } else {
         // Custom output directory specified
         outputDir = argv.constantsOutput!;
       }
-      
-      MessageFormatter.info(`Generating constants for languages: ${languages.join(", ")}`, { prefix: "Constants" });
-      
+
+      MessageFormatter.info(
+        `Generating constants for languages: ${languages.join(", ")}`,
+        { prefix: "Constants" }
+      );
+
       const generator = new ConstantsGenerator(controller.config);
       await generator.generateFiles(languages, outputDir);
-      
+
       operationStats.generatedConstants = languages.length;
-      MessageFormatter.success(`Constants generated in ${outputDir}`, { prefix: "Constants" });
+      MessageFormatter.success(`Constants generated in ${outputDir}`, {
+        prefix: "Constants",
+      });
       return;
     }
 
     if (argv.migrateCollectionsToTables) {
       try {
         if (!controller.config) {
-          MessageFormatter.error("No Appwrite configuration found", undefined, { prefix: "Migration" });
+          MessageFormatter.error("No Appwrite configuration found", undefined, {
+            prefix: "Migration",
+          });
           return;
         }
 
@@ -735,8 +865,15 @@ async function main() {
           if (fs.existsSync(defaultPath)) {
             configPath = defaultPath;
           } else {
-            MessageFormatter.error("Could not determine configuration folder path", undefined, { prefix: "Migration" });
-            MessageFormatter.info("Make sure you have a .appwrite/ folder in your current directory", { prefix: "Migration" });
+            MessageFormatter.error(
+              "Could not determine configuration folder path",
+              undefined,
+              { prefix: "Migration" }
+            );
+            MessageFormatter.info(
+              "Make sure you have a .appwrite/ folder in your current directory",
+              { prefix: "Migration" }
+            );
             return;
           }
         }
@@ -744,32 +881,62 @@ async function main() {
         // Check if migration conditions are met
         const migrationCheck = checkMigrationConditions(configPath);
         if (!migrationCheck.allowed) {
-          MessageFormatter.error(`Migration not allowed: ${migrationCheck.reason}`, undefined, { prefix: "Migration" });
-          MessageFormatter.info("Migration requirements:", { prefix: "Migration" });
-          MessageFormatter.info("  • Configuration must be loaded (use --config or have .appwrite/ folder)", { prefix: "Migration" });
-          MessageFormatter.info("  • collections/ folder must exist with YAML files", { prefix: "Migration" });
-          MessageFormatter.info("  • tables/ folder must not exist or be empty", { prefix: "Migration" });
+          MessageFormatter.error(
+            `Migration not allowed: ${migrationCheck.reason}`,
+            undefined,
+            { prefix: "Migration" }
+          );
+          MessageFormatter.info("Migration requirements:", {
+            prefix: "Migration",
+          });
+          MessageFormatter.info(
+            "  • Configuration must be loaded (use --config or have .appwrite/ folder)",
+            { prefix: "Migration" }
+          );
+          MessageFormatter.info(
+            "  • collections/ folder must exist with YAML files",
+            { prefix: "Migration" }
+          );
+          MessageFormatter.info(
+            "  • tables/ folder must not exist or be empty",
+            { prefix: "Migration" }
+          );
           return;
         }
 
-        const { migrateCollectionsToTables } = await import("./config/configMigration.js");
+        const { migrateCollectionsToTables } = await import(
+          "./config/configMigration.js"
+        );
 
-        MessageFormatter.info("Starting collections to tables migration...", { prefix: "Migration" });
+        MessageFormatter.info("Starting collections to tables migration...", {
+          prefix: "Migration",
+        });
         const result = migrateCollectionsToTables(controller.config, {
           strategy: "full_migration",
           validateResult: true,
-          dryRun: false
+          dryRun: false,
         });
 
         if (result.success) {
           operationStats.migratedCollections = result.changes.length;
-          MessageFormatter.success("Collections migration completed successfully", { prefix: "Migration" });
+          MessageFormatter.success(
+            "Collections migration completed successfully",
+            { prefix: "Migration" }
+          );
         } else {
-          MessageFormatter.error(`Migration failed: ${result.errors.join(", ")}`, undefined, { prefix: "Migration" });
+          MessageFormatter.error(
+            `Migration failed: ${result.errors.join(", ")}`,
+            undefined,
+            { prefix: "Migration" }
+          );
           process.exit(1);
         }
       } catch (error) {
-        MessageFormatter.error("Migration failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Migration" });
+        MessageFormatter.error(
+          "Migration failed",
+          error instanceof Error ? error : new Error(String(error)),
+          { prefix: "Migration" }
+        );
         process.exit(1);
       }
       return;
@@ -780,17 +947,41 @@ async function main() {
       const availableSessions = getAvailableSessions();
 
       if (availableSessions.length > 0) {
-        MessageFormatter.error("No Appwrite configuration found", undefined, { prefix: "CLI" });
-        MessageFormatter.info("Available authentication options:", { prefix: "Auth" });
-        MessageFormatter.info("• Session authentication: Add --session flag", { prefix: "Auth" });
-        MessageFormatter.info("• API key authentication: Add --apiKey YOUR_API_KEY", { prefix: "Auth" });
-        MessageFormatter.info(`• Available sessions: ${availableSessions.map(s => `${s.projectId} (${s.email || 'unknown'})`).join(", ")}`, { prefix: "Auth" });
+        MessageFormatter.error("No Appwrite configuration found", undefined, {
+          prefix: "CLI",
+        });
+        MessageFormatter.info("Available authentication options:", {
+          prefix: "Auth",
+        });
+        MessageFormatter.info("• Session authentication: Add --session flag", {
+          prefix: "Auth",
+        });
+        MessageFormatter.info(
+          "• API key authentication: Add --apiKey YOUR_API_KEY",
+          { prefix: "Auth" }
+        );
+        MessageFormatter.info(
+          `• Available sessions: ${availableSessions
+            .map((s) => `${s.projectId} (${s.email || "unknown"})`)
+            .join(", ")}`,
+          { prefix: "Auth" }
+        );
       } else {
-        MessageFormatter.error("No Appwrite configuration found", undefined, { prefix: "CLI" });
+        MessageFormatter.error("No Appwrite configuration found", undefined, {
+          prefix: "CLI",
+        });
         MessageFormatter.info("Authentication options:", { prefix: "Auth" });
-        MessageFormatter.info("• Login with Appwrite CLI: Run 'appwrite login' then use --session flag", { prefix: "Auth" });
-        MessageFormatter.info("• Use API key: Add --apiKey YOUR_API_KEY", { prefix: "Auth" });
-        MessageFormatter.info("• Create config file: Run with --setup to initialize project configuration", { prefix: "Auth" });
+        MessageFormatter.info(
+          "• Login with Appwrite CLI: Run 'appwrite login' then use --session flag",
+          { prefix: "Auth" }
+        );
+        MessageFormatter.info("• Use API key: Add --apiKey YOUR_API_KEY", {
+          prefix: "Auth",
+        });
+        MessageFormatter.info(
+          "• Create config file: Run with --setup to initialize project configuration",
+          { prefix: "Auth" }
+        );
       }
       return;
     }
@@ -803,14 +994,16 @@ async function main() {
       const { listBackups } = await import("./shared/backupTracking.js");
 
       if (!controller.config) {
-        MessageFormatter.error("No Appwrite configuration found", undefined, { prefix: "Backups" });
+        MessageFormatter.error("No Appwrite configuration found", undefined, {
+          prefix: "Backups",
+        });
         return;
       }
 
       const { adapter } = await AdapterFactory.create({
         appwriteEndpoint: controller.config.appwriteEndpoint,
         appwriteProject: controller.config.appwriteProject,
-        appwriteKey: controller.config.appwriteKey
+        appwriteKey: controller.config.appwriteKey,
       });
 
       const databases = parsedArgv.dbIds
@@ -825,7 +1018,10 @@ async function main() {
       for (const db of databases!) {
         const backups = await listBackups(adapter, db.$id);
 
-        MessageFormatter.info(`\nBackups for database: ${db.name} (${db.$id})`, { prefix: "Backups" });
+        MessageFormatter.info(
+          `\nBackups for database: ${db.name} (${db.$id})`,
+          { prefix: "Backups" }
+        );
 
         if (backups.length === 0) {
           MessageFormatter.info("  No backups found", { prefix: "Backups" });
@@ -834,7 +1030,11 @@ async function main() {
             const date = new Date(backup.$createdAt).toLocaleString();
             const size = MessageFormatter.formatBytes(backup.sizeBytes);
             MessageFormatter.info(
-              `  ${index + 1}. ${date} - ${backup.format.toUpperCase()} - ${size} - ${backup.collections} collections, ${backup.documents} documents`,
+              `  ${
+                index + 1
+              }. ${date} - ${backup.format.toUpperCase()} - ${size} - ${
+                backup.collections
+              } collections, ${backup.documents} documents`,
               { prefix: "Backups" }
             );
           });
@@ -893,12 +1093,20 @@ async function main() {
     }
 
     // Add default databases if not specified (only if we need them for operations)
-    const needsDatabases = options.doBackup || options.wipeDatabase ||
-                          options.wipeDocumentStorage || options.wipeUsers ||
-                          options.wipeCollections || options.importData ||
-                          parsedArgv.sync || parsedArgv.transfer;
+    const needsDatabases =
+      options.doBackup ||
+      options.wipeDatabase ||
+      options.wipeDocumentStorage ||
+      options.wipeUsers ||
+      options.wipeCollections ||
+      options.importData ||
+      parsedArgv.sync ||
+      parsedArgv.transfer;
 
-    if (needsDatabases && (!options.databases || options.databases.length === 0)) {
+    if (
+      needsDatabases &&
+      (!options.databases || options.databases.length === 0)
+    ) {
       const allDatabases = await fetchAllDatabases(controller.database!);
       options.databases = allDatabases;
     }
@@ -906,7 +1114,9 @@ async function main() {
     // Add default collections if not specified
     if (!options.collections || options.collections.length === 0) {
       if (controller.config && controller.config.collections) {
-        options.collections = controller.config.collections.map((c) => c.name);
+        options.collections = controller.config.collections.map(
+          (c: any) => c.name
+        );
       } else {
         options.collections = [];
       }
@@ -914,7 +1124,9 @@ async function main() {
 
     // Comprehensive backup (all databases + all buckets)
     if (parsedArgv.comprehensiveBackup) {
-      const { comprehensiveBackup } = await import("./backups/operations/comprehensiveBackup.js");
+      const { comprehensiveBackup } = await import(
+        "./backups/operations/comprehensiveBackup.js"
+      );
       const { AdapterFactory } = await import("./adapters/AdapterFactory.js");
 
       // Get tracking database ID (interactive prompt if not specified)
@@ -925,42 +1137,55 @@ async function main() {
         const allDatabases = await fetchAllDatabases(controller.database!);
 
         if (allDatabases.length === 0) {
-          MessageFormatter.error("No databases found. Cannot create comprehensive backup without a tracking database.", undefined, { prefix: "Backup" });
+          MessageFormatter.error(
+            "No databases found. Cannot create comprehensive backup without a tracking database.",
+            undefined,
+            { prefix: "Backup" }
+          );
           return;
         }
 
         if (allDatabases.length === 1) {
           trackingDatabaseId = allDatabases[0].$id;
-          MessageFormatter.info(`Using only available database for tracking: ${allDatabases[0].name} (${trackingDatabaseId})`, { prefix: "Backup" });
+          MessageFormatter.info(
+            `Using only available database for tracking: ${allDatabases[0].name} (${trackingDatabaseId})`,
+            { prefix: "Backup" }
+          );
         } else {
           // Interactive selection
           const inquirer = (await import("inquirer")).default;
-          const answer = await inquirer.prompt([{
-            type: 'list',
-            name: 'trackingDb',
-            message: 'Select database to store backup tracking metadata:',
-            choices: allDatabases.map(db => ({
-              name: `${db.name} (${db.$id})`,
-              value: db.$id
-            }))
-          }]);
+          const answer = await inquirer.prompt([
+            {
+              type: "list",
+              name: "trackingDb",
+              message: "Select database to store backup tracking metadata:",
+              choices: allDatabases.map((db) => ({
+                name: `${db.name} (${db.$id})`,
+                value: db.$id,
+              })),
+            },
+          ]);
           trackingDatabaseId = answer.trackingDb;
         }
       }
 
       // Ensure trackingDatabaseId is defined before proceeding
       if (!trackingDatabaseId) {
-        throw new Error('Tracking database ID is required for comprehensive backup');
+        throw new Error(
+          "Tracking database ID is required for comprehensive backup"
+        );
       }
 
-      MessageFormatter.info(`Using tracking database: ${trackingDatabaseId}`, { prefix: "Backup" });
+      MessageFormatter.info(`Using tracking database: ${trackingDatabaseId}`, {
+        prefix: "Backup",
+      });
 
       // Create adapter for backup tracking
       const { adapter } = await AdapterFactory.create({
         appwriteEndpoint: controller.config!.appwriteEndpoint,
         appwriteProject: controller.config!.appwriteProject,
         appwriteKey: controller.config!.appwriteKey,
-        sessionCookie: controller.config!.sessionCookie
+        sessionCookie: controller.config!.sessionCookie,
       });
 
       const result = await comprehensiveBackup(
@@ -970,11 +1195,11 @@ async function main() {
         adapter,
         {
           trackingDatabaseId,
-          backupFormat: parsedArgv.backupFormat || 'zip',
+          backupFormat: parsedArgv.backupFormat || "zip",
           parallelDownloads: parsedArgv.parallelDownloads || 10,
           onProgress: (message) => {
             MessageFormatter.info(message, { prefix: "Backup" });
-          }
+          },
         }
       );
 
@@ -983,24 +1208,44 @@ async function main() {
       operationStats.bucketsBackedUp = result.bucketBackups.length;
       operationStats.totalBackupSize = result.totalSizeBytes;
 
-      if (result.status === 'completed') {
-        MessageFormatter.success(`Comprehensive backup completed successfully (ID: ${result.backupId})`, { prefix: "Backup" });
-      } else if (result.status === 'partial') {
-        MessageFormatter.warning(`Comprehensive backup completed with errors (ID: ${result.backupId})`, { prefix: "Backup" });
-        result.errors.forEach(err => MessageFormatter.warning(err, { prefix: "Backup" }));
+      if (result.status === "completed") {
+        MessageFormatter.success(
+          `Comprehensive backup completed successfully (ID: ${result.backupId})`,
+          { prefix: "Backup" }
+        );
+      } else if (result.status === "partial") {
+        MessageFormatter.warning(
+          `Comprehensive backup completed with errors (ID: ${result.backupId})`,
+          { prefix: "Backup" }
+        );
+        result.errors.forEach((err) =>
+          MessageFormatter.warning(err, { prefix: "Backup" })
+        );
       } else {
-        MessageFormatter.error(`Comprehensive backup failed (ID: ${result.backupId})`, undefined, { prefix: "Backup" });
-        result.errors.forEach(err => MessageFormatter.error(err, undefined, { prefix: "Backup" }));
+        MessageFormatter.error(
+          `Comprehensive backup failed (ID: ${result.backupId})`,
+          undefined,
+          { prefix: "Backup" }
+        );
+        result.errors.forEach((err) =>
+          MessageFormatter.error(err, undefined, { prefix: "Backup" })
+        );
       }
     }
 
     if (options.doBackup && options.databases) {
-      MessageFormatter.info(`Creating backups for ${options.databases.length} database(s) in ${parsedArgv.backupFormat} format`, { prefix: "Backup" });
+      MessageFormatter.info(
+        `Creating backups for ${options.databases.length} database(s) in ${parsedArgv.backupFormat} format`,
+        { prefix: "Backup" }
+      );
       for (const db of options.databases) {
-        await controller.backupDatabase(db, parsedArgv.backupFormat || 'json');
+        await controller.backupDatabase(db, parsedArgv.backupFormat || "json");
       }
       operationStats.backups = options.databases.length;
-      MessageFormatter.success(`Backup completed for ${options.databases.length} database(s)`, { prefix: "Backup" });
+      MessageFormatter.success(
+        `Backup completed for ${options.databases.length} database(s)`,
+        { prefix: "Backup" }
+      );
     }
 
     if (
@@ -1010,19 +1255,22 @@ async function main() {
       options.wipeCollections
     ) {
       // Confirm destructive operations
-      const databaseNames = options.databases?.map(db => db.name) || [];
-      const confirmed = await ConfirmationDialogs.confirmDatabaseWipe(databaseNames, {
-        includeStorage: options.wipeDocumentStorage,
-        includeUsers: options.wipeUsers
-      });
-      
+      const databaseNames = options.databases?.map((db) => db.name) || [];
+      const confirmed = await ConfirmationDialogs.confirmDatabaseWipe(
+        databaseNames,
+        {
+          includeStorage: options.wipeDocumentStorage,
+          includeUsers: options.wipeUsers,
+        }
+      );
+
       if (!confirmed) {
         MessageFormatter.info("Operation cancelled by user", { prefix: "CLI" });
         return;
       }
-      
+
       let wipeStats = { databases: 0, collections: 0, users: 0, buckets: 0 };
-      
+
       if (parsedArgv.wipe === "all") {
         if (options.databases) {
           for (const db of options.databases) {
@@ -1061,14 +1309,15 @@ async function main() {
           const collectionsToWipe = dbCollections.filter((c) =>
             options.collections!.includes(c.$id)
           );
-          
+
           // Confirm collection wipe
-          const collectionNames = collectionsToWipe.map(c => c.name);
-          const collectionConfirmed = await ConfirmationDialogs.confirmCollectionWipe(
-            db.name,
-            collectionNames
-          );
-          
+          const collectionNames = collectionsToWipe.map((c) => c.name);
+          const collectionConfirmed =
+            await ConfirmationDialogs.confirmCollectionWipe(
+              db.name,
+              collectionNames
+            );
+
           if (collectionConfirmed) {
             for (const collection of collectionsToWipe) {
               await controller.wipeCollection(db, collection);
@@ -1077,9 +1326,14 @@ async function main() {
           }
         }
       }
-      
+
       // Show wipe operation summary
-      if (wipeStats.databases > 0 || wipeStats.collections > 0 || wipeStats.users > 0 || wipeStats.buckets > 0) {
+      if (
+        wipeStats.databases > 0 ||
+        wipeStats.collections > 0 ||
+        wipeStats.users > 0 ||
+        wipeStats.buckets > 0
+      ) {
         operationStats.wipedDatabases = wipeStats.databases;
         operationStats.wipedCollections = wipeStats.collections;
         operationStats.wipedUsers = wipeStats.users;
@@ -1087,16 +1341,103 @@ async function main() {
       }
     }
 
-    if (parsedArgv.push) {
-      // PUSH: Use LOCAL config collections only (pass empty array to use config.collections)
-      const databases =
-        options.databases || (await fetchAllDatabases(controller.database!));
-
-      // Pass empty array - syncDb will use config.collections (local schema)
-      await controller.syncDb(databases, []);
-      operationStats.pushedDatabases = databases.length;
-      operationStats.pushedCollections = controller.config?.collections?.length || 0;
-    } else if (parsedArgv.sync) {
+    if (parsedArgv.push) {
+      await controller.init();
+      if (!controller.database || !controller.config) {
+        MessageFormatter.error("Database or config not initialized", undefined, { prefix: "Push" });
+        return;
+      }
+
+      // Fetch available DBs
+      const availableDatabases = await fetchAllDatabases(controller.database);
+      if (availableDatabases.length === 0) {
+        MessageFormatter.warning("No databases found in remote project", { prefix: "Push" });
+        return;
+      }
+
+      // Determine selected DBs
+      let selectedDbIds: string[] = [];
+      if (parsedArgv.dbIds) {
+        selectedDbIds = parsedArgv.dbIds.split(/[,\s]+/).filter(Boolean);
+      } else {
+        selectedDbIds = await SelectionDialogs.selectDatabases(
+          availableDatabases,
+          controller.config.databases || [],
+          { showSelectAll: false, allowNewOnly: false, defaultSelected: [] }
+        );
+      }
+
+      if (selectedDbIds.length === 0) {
+        MessageFormatter.warning("No databases selected for push", { prefix: "Push" });
+        return;
+      }
+
+      // Build DatabaseSelection[] with tableIds per DB
+      const databaseSelections: DatabaseSelection[] = [];
+      const allConfigItems = controller.config.collections || controller.config.tables || [];
+
+      for (const dbId of selectedDbIds) {
+        const db = availableDatabases.find(d => d.$id === dbId);
+        if (!db) continue;
+
+        // Filter config items eligible for this DB according to databaseId/databaseIds rule
+        const eligibleConfigItems = (allConfigItems as any[]).filter(item => {
+          const one = item.databaseId as string | undefined;
+          const many = item.databaseIds as string[] | undefined;
+          if (Array.isArray(many) && many.length > 0) return many.includes(dbId);
+          if (one) return one === dbId;
+          return true; // eligible everywhere if unspecified
+        });
+
+        // Fetch available tables from remote for selection context
+        const availableTables = await fetchAllCollections(dbId, controller.database);
+
+        // Determine selected table IDs
+        let selectedTableIds: string[] = [];
+        if (parsedArgv.collectionIds) {
+          const ids = parsedArgv.collectionIds.split(/[,\s]+/).filter(Boolean);
+          // Only allow IDs that are in eligible config items
+          const eligibleIds = new Set(eligibleConfigItems.map((c: any) => c.$id || c.id));
+          selectedTableIds = ids.filter(id => eligibleIds.has(id));
+        } else {
+          selectedTableIds = await SelectionDialogs.selectTablesForDatabase(
+            dbId,
+            db.name,
+            availableTables,
+            eligibleConfigItems,
+            { showSelectAll: false, allowNewOnly: true, defaultSelected: [] }
+          );
+        }
+
+        databaseSelections.push({
+          databaseId: db.$id,
+          databaseName: db.name,
+          tableIds: selectedTableIds,
+          tableNames: [],
+          isNew: false,
+        });
+      }
+
+      if (databaseSelections.every(sel => sel.tableIds.length === 0)) {
+        MessageFormatter.warning("No tables/collections selected for push", { prefix: "Push" });
+        return;
+      }
+
+      const pushSummary: Record<string, string | number | string[]> = {
+        databases: databaseSelections.length,
+        collections: databaseSelections.reduce((sum, s) => sum + s.tableIds.length, 0),
+        details: databaseSelections.map(s => `${s.databaseId}: ${s.tableIds.length} items`),
+      };
+      const confirmed = await ConfirmationDialogs.showOperationSummary('Push', pushSummary, { confirmationRequired: true });
+      if (!confirmed) {
+        MessageFormatter.info("Push operation cancelled", { prefix: "Push" });
+        return;
+      }
+
+      await controller.selectivePush(databaseSelections, []);
+      operationStats.pushedDatabases = databaseSelections.length;
+      operationStats.pushedCollections = databaseSelections.reduce((sum, s) => sum + s.tableIds.length, 0);
+    } else if (parsedArgv.sync) {
       // Enhanced SYNC: Pull from remote with intelligent configuration detection
       if (parsedArgv.autoSync) {
         // Legacy behavior: sync everything without prompts
@@ -1142,7 +1483,9 @@ async function main() {
           await controller.getDatabasesByIds([parsedArgv.fromDbId])
         )?.[0];
         if (!fromDb) {
-          MessageFormatter.error("Source database not found", undefined, { prefix: "Transfer" });
+          MessageFormatter.error("Source database not found", undefined, {
+            prefix: "Transfer",
+          });
           return;
         }
         if (isRemote) {
@@ -1163,19 +1506,27 @@ async function main() {
           const remoteDbs = await fetchAllDatabases(targetDatabases);
           toDb = remoteDbs.find((db) => db.$id === parsedArgv.toDbId);
           if (!toDb) {
-            MessageFormatter.error("Target database not found", undefined, { prefix: "Transfer" });
+            MessageFormatter.error("Target database not found", undefined, {
+              prefix: "Transfer",
+            });
             return;
           }
         } else {
           toDb = (await controller.getDatabasesByIds([parsedArgv.toDbId]))?.[0];
           if (!toDb) {
-            MessageFormatter.error("Target database not found", undefined, { prefix: "Transfer" });
+            MessageFormatter.error("Target database not found", undefined, {
+              prefix: "Transfer",
+            });
             return;
           }
         }
 
         if (!fromDb || !toDb) {
-          MessageFormatter.error("Source or target database not found", undefined, { prefix: "Transfer" });
+          MessageFormatter.error(
+            "Source or target database not found",
+            undefined,
+            { prefix: "Transfer" }
+          );
           return;
         }
       }
@@ -1225,11 +1576,15 @@ async function main() {
       await controller.transferData(transferOptions);
       operationStats.transfers = 1;
     }
-    
+
     // Show final operation summary if any operations were performed
     if (Object.keys(operationStats).length > 0) {
       const duration = Date.now() - startTime;
-      MessageFormatter.operationSummary("CLI Operations", operationStats, duration);
+      MessageFormatter.operationSummary(
+        "CLI Operations",
+        operationStats,
+        duration
+      );
     }
   }
 }