appwrite-utils-cli 1.7.8 → 1.8.1

package/dist/main.js

@@ -18,9 +18,9 @@ import { logger } from "./shared/logging.js";
 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.require) {
     globalThis.require = require;
@@ -76,13 +76,13 @@ async function performEnhancedSync(controller, parsedArgv) {
                     isNew: false
                 }));
                 const selectionSummary = SelectionDialogs.createSyncSelectionSummary(databaseSelections, bucketSelections);
-                const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary);
+                const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary, 'pull');
                 if (!confirmed) {
-                    MessageFormatter.info("Sync operation cancelled by user", { prefix: "Sync" });
+                    MessageFormatter.info("Pull operation cancelled by user", { prefix: "Sync" });
                     return null;
                 }
-                // Perform sync with existing configuration
-                await controller.selectiveSync(databaseSelections, bucketSelections);
+                // Perform sync with existing configuration (pull from remote)
+                await controller.selectivePull(databaseSelections, bucketSelections);
                 return selectionSummary;
             }
         }
@@ -94,9 +94,9 @@ async function performEnhancedSync(controller, parsedArgv) {
         const allowNewOnly = !syncExisting;
         // Select databases
         const selectedDatabaseIds = await SelectionDialogs.selectDatabases(availableDatabases, configuredDatabases, {
-            showSelectAll: true,
+            showSelectAll: false,
             allowNewOnly,
-            defaultSelected: syncExisting ? configuredDatabases.map(db => db.$id) : []
+            defaultSelected: []
         });
         if (selectedDatabaseIds.length === 0) {
             MessageFormatter.warning("No databases selected for sync", { prefix: "Sync" });
@@ -116,9 +116,9 @@ async function performEnhancedSync(controller, parsedArgv) {
             const configuredTables = controller.config.collections || [];
             // Select tables for this database
             const selectedTableIds = await SelectionDialogs.selectTablesForDatabase(databaseId, database.name, availableTables, configuredTables, {
-                showSelectAll: true,
+                showSelectAll: false,
                 allowNewOnly,
-                defaultSelected: syncExisting ? configuredTables.map((t) => t.$id) : []
+                defaultSelected: []
             });
             tableSelectionsMap.set(databaseId, selectedTableIds);
             if (selectedTableIds.length === 0) {
@@ -137,10 +137,10 @@ async function performEnhancedSync(controller, parsedArgv) {
                 // you'd fetch this from the Appwrite API
                 const availableBuckets = configuredBuckets; // Placeholder
                 selectedBucketIds = await SelectionDialogs.selectBucketsForDatabases(selectedDatabaseIds, availableBuckets, configuredBuckets, {
-                    showSelectAll: true,
+                    showSelectAll: false,
                     allowNewOnly: parsedArgv.selectBuckets ? false : allowNewOnly,
                     groupByDatabase: true,
-                    defaultSelected: syncExisting ? configuredBuckets.map(b => b.$id) : []
+                    defaultSelected: []
                 });
             }
             catch (error) {
@@ -154,13 +154,13 @@ async function performEnhancedSync(controller, parsedArgv) {
         configuredBuckets, availableDatabases);
         // Show final confirmation
         const selectionSummary = SelectionDialogs.createSyncSelectionSummary(databaseSelections, bucketSelections);
-        const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary);
+        const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary, 'pull');
         if (!confirmed) {
-            MessageFormatter.info("Sync operation cancelled by user", { prefix: "Sync" });
+            MessageFormatter.info("Pull operation cancelled by user", { prefix: "Sync" });
             return null;
         }
-        // Perform the selective sync
-        await controller.selectiveSync(databaseSelections, bucketSelections);
+        // Perform the selective sync (pull from remote)
+        await controller.selectivePull(databaseSelections, bucketSelections);
         MessageFormatter.success("Enhanced sync completed successfully", { prefix: "Sync" });
         return selectionSummary;
     }
@@ -185,24 +185,28 @@ function checkMigrationConditions(configPath) {
     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.`,
             };
         }
     }
@@ -433,16 +437,23 @@ async function main() {
         // Enhanced config creation with session and project file support
         let directConfig = 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" });
+                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" });
             }
             else {
-                MessageFormatter.info("No active Appwrite sessions found", { 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" });
             }
@@ -457,7 +468,11 @@ async function main() {
             }
         }
         // 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,
@@ -482,7 +497,9 @@ async function main() {
                 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(`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 {
@@ -503,11 +520,16 @@ async function main() {
         // 3. Auto-detect session authentication when possible
         let finalDirectConfig = directConfig;
         if ((argv.useSession || argv.sessionCookie) &&
-            (!directConfig || !directConfig.appwriteEndpoint || !directConfig.appwriteProject)) {
+            (!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" });
@@ -539,10 +561,14 @@ async function main() {
         if (argv.generateConstants) {
             const { ConstantsGenerator } = await import("./utils/constantsGenerator.js");
             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());
+            const languages = argv
+                .constantsLanguages.split(",")
+                .map((l) => l.trim());
             // Determine output directory - use config folder/constants by default, or custom path if specified
             let outputDir;
             if (argv.constantsOutput === "auto") {
@@ -560,13 +586,17 @@ async function main() {
             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;
                 }
                 // Get the config path from the controller or use .appwrite in current directory
@@ -587,18 +617,22 @@ async function main() {
                 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("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");
-                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;
@@ -619,17 +653,29 @@ async function main() {
             // Provide better guidance based on available authentication methods
             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.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.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("• 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;
@@ -640,13 +686,15 @@ async function main() {
             const { AdapterFactory } = await import("./adapters/AdapterFactory.js");
             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
                 ? await controller.getDatabasesByIds(parsedArgv.dbIds.split(","))
@@ -699,11 +747,16 @@ async function main() {
             await controller.updateFunctionSpecifications(parsedArgv.functionId, parsedArgv.specification);
         }
         // 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;
-        if (needsDatabases && (!options.databases || options.databases.length === 0)) {
+        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)) {
             const allDatabases = await fetchAllDatabases(controller.database);
             options.databases = allDatabases;
         }
@@ -736,58 +789,62 @@ async function main() {
                 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 => ({
+                    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
-                            }))
-                        }]);
+                                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(controller.config, controller.database, controller.storage, adapter, {
                 trackingDatabaseId,
-                backupFormat: parsedArgv.backupFormat || 'zip',
+                backupFormat: parsedArgv.backupFormat || "zip",
                 parallelDownloads: parsedArgv.parallelDownloads || 10,
                 onProgress: (message) => {
                     MessageFormatter.info(message, { prefix: "Backup" });
-                }
+                },
             });
             operationStats.comprehensiveBackup = 1;
             operationStats.databasesBackedUp = result.databaseBackups.length;
             operationStats.bucketsBackedUp = result.bucketBackups.length;
             operationStats.totalBackupSize = result.totalSizeBytes;
-            if (result.status === 'completed') {
+            if (result.status === "completed") {
                 MessageFormatter.success(`Comprehensive backup completed successfully (ID: ${result.backupId})`, { prefix: "Backup" });
             }
-            else if (result.status === 'partial') {
+            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" }));
+                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" }));
+                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" });
             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" });
@@ -797,10 +854,10 @@ async function main() {
             options.wipeUsers ||
             options.wipeCollections) {
             // Confirm destructive operations
-            const databaseNames = options.databases?.map(db => db.name) || [];
+            const databaseNames = options.databases?.map((db) => db.name) || [];
             const confirmed = await ConfirmationDialogs.confirmDatabaseWipe(databaseNames, {
                 includeStorage: options.wipeDocumentStorage,
-                includeUsers: options.wipeUsers
+                includeUsers: options.wipeUsers,
             });
             if (!confirmed) {
                 MessageFormatter.info("Operation cancelled by user", { prefix: "CLI" });
@@ -842,7 +899,7 @@ async function main() {
                     const dbCollections = await fetchAllCollections(db.$id, controller.database);
                     const collectionsToWipe = dbCollections.filter((c) => options.collections.includes(c.$id));
                     // Confirm collection wipe
-                    const collectionNames = collectionsToWipe.map(c => c.name);
+                    const collectionNames = collectionsToWipe.map((c) => c.name);
                     const collectionConfirmed = await ConfirmationDialogs.confirmCollectionWipe(db.name, collectionNames);
                     if (collectionConfirmed) {
                         for (const collection of collectionsToWipe) {
@@ -853,7 +910,10 @@ 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;
@@ -861,12 +921,84 @@ 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;
+            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 = [];
+            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 = [];
+            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.filter(item => {
+                    const one = item.databaseId;
+                    const many = item.databaseIds;
+                    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 = [];
+                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) => 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 = {
+                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
@@ -905,7 +1037,9 @@ async function main() {
                 MessageFormatter.info(`Starting database transfer from ${parsedArgv.fromDbId} to ${parsedArgv.toDbId}`, { prefix: "Transfer" });
                 fromDb = (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) {
@@ -920,14 +1054,18 @@ 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;
                     }
                 }