appwrite-utils-cli 1.5.1 → 1.6.0

package/dist/interactiveCLI.js

@@ -1,31 +1,31 @@
 import inquirer from "inquirer";
 import { UtilsController } from "./utilsController.js";
-import { createEmptyCollection, setupDirsFiles } from "./utils/setupFiles.js";
-import { fetchAllDatabases } from "./databases/methods.js";
 import { fetchAllCollections } from "./collections/methods.js";
 import { listBuckets, createBucket } from "./storage/methods.js";
 import { Databases, Storage, Client, Compression, Query, Functions, } from "node-appwrite";
-import { getClient } from "./utils/getClientFromConfig.js";
-import { ComprehensiveTransfer } from "./migrations/comprehensiveTransfer.js";
-import { AppwriteFunctionSchema, parseAttribute, PermissionToAppwritePermission, RuntimeSchema, permissionSchema, } from "appwrite-utils";
+import { PermissionToAppwritePermission, RuntimeSchema, permissionSchema, } from "appwrite-utils";
 import { ulid } from "ulidx";
 import chalk from "chalk";
 import { DateTime } from "luxon";
-import { createFunctionTemplate, deleteFunction, downloadLatestFunctionDeployment, getFunction, listFunctions, listSpecifications, } from "./functions/methods.js";
-import { deployLocalFunction } from "./functions/deployments.js";
+import { getFunction, downloadLatestFunctionDeployment, listFunctions, } from "./functions/methods.js";
 import { join } from "node:path";
 import path from "path";
 import fs from "node:fs";
 import os from "node:os";
-import { SchemaGenerator } from "./shared/schemaGenerator.js";
-import { ConfirmationDialogs } from "./shared/confirmationDialogs.js";
 import { MessageFormatter } from "./shared/messageFormatter.js";
-import { migrateConfig } from "./utils/configMigration.js";
 import { findAppwriteConfig } from "./utils/loadConfigs.js";
-import { findYamlConfig, addFunctionToYamlConfig } from "./config/yamlConfig.js";
+import { findYamlConfig } from "./config/yamlConfig.js";
+// Import command modules
+import { configCommands } from "./cli/commands/configCommands.js";
+import { databaseCommands } from "./cli/commands/databaseCommands.js";
+import { functionCommands } from "./cli/commands/functionCommands.js";
+import { transferCommands } from "./cli/commands/transferCommands.js";
+import { schemaCommands } from "./cli/commands/schemaCommands.js";
 var CHOICES;
 (function (CHOICES) {
     CHOICES["MIGRATE_CONFIG"] = "\uD83D\uDD04 Migrate TypeScript config to YAML (.appwrite structure)";
+    CHOICES["VALIDATE_CONFIG"] = "\u2705 Validate configuration (collections/tables conflicts)";
+    CHOICES["MIGRATE_COLLECTIONS_TO_TABLES"] = "\uD83D\uDD00 Migrate collections to tables format";
     CHOICES["CREATE_COLLECTION_CONFIG"] = "\uD83D\uDCC4 Create collection config file";
     CHOICES["CREATE_FUNCTION"] = "\u26A1 Create a new function, from scratch or using a template";
     CHOICES["DEPLOY_FUNCTION"] = "\uD83D\uDE80 Deploy function(s)";
@@ -77,75 +77,80 @@ export class InteractiveCLI {
             ]);
             switch (action) {
                 case CHOICES.MIGRATE_CONFIG:
-                    await this.migrateTypeScriptConfig();
+                    await configCommands.migrateTypeScriptConfig(this);
+                    break;
+                case CHOICES.VALIDATE_CONFIG:
+                    await configCommands.validateConfiguration(this);
+                    break;
+                case CHOICES.MIGRATE_COLLECTIONS_TO_TABLES:
+                    await configCommands.migrateCollectionsToTables(this);
                     break;
                 case CHOICES.CREATE_COLLECTION_CONFIG:
-                    await this.createCollectionConfig();
+                    await configCommands.createCollectionConfig(this);
                     break;
                 case CHOICES.CREATE_FUNCTION:
                     await this.initControllerIfNeeded();
-                    await this.createFunction();
+                    await functionCommands.createFunction(this);
                     break;
                 case CHOICES.DEPLOY_FUNCTION:
                     await this.initControllerIfNeeded();
-                    await this.deployFunction();
+                    await functionCommands.deployFunction(this);
                     break;
                 case CHOICES.DELETE_FUNCTION:
                     await this.initControllerIfNeeded();
-                    await this.deleteFunction();
+                    await functionCommands.deleteFunction(this);
                     break;
                 case CHOICES.SETUP_DIRS_FILES:
-                    await setupDirsFiles(false, this.currentDir);
+                    await schemaCommands.setupDirsFiles(this, false);
                     break;
                 case CHOICES.SETUP_DIRS_FILES_WITH_EXAMPLE_DATA:
-                    await setupDirsFiles(true, this.currentDir);
+                    await schemaCommands.setupDirsFiles(this, true);
                     break;
                 case CHOICES.SYNCHRONIZE_CONFIGURATIONS:
                     await this.initControllerIfNeeded();
-                    await this.synchronizeConfigurations();
+                    await databaseCommands.synchronizeConfigurations(this);
                     break;
                 case CHOICES.SYNC_DB:
                     await this.initControllerIfNeeded();
-                    await this.syncDb();
+                    await databaseCommands.syncDb(this);
                     break;
                 case CHOICES.TRANSFER_DATA:
                     await this.initControllerIfNeeded();
-                    await this.transferData();
+                    await transferCommands.transferData(this);
                     break;
                 case CHOICES.COMPREHENSIVE_TRANSFER:
-                    await this.comprehensiveTransfer();
+                    await transferCommands.comprehensiveTransfer(this);
                     break;
                 case CHOICES.BACKUP_DATABASE:
                     await this.initControllerIfNeeded();
-                    await this.backupDatabase();
+                    await databaseCommands.backupDatabase(this);
                     break;
                 case CHOICES.WIPE_DATABASE:
                     await this.initControllerIfNeeded();
-                    await this.wipeDatabase();
+                    await databaseCommands.wipeDatabase(this);
                     break;
                 case CHOICES.WIPE_COLLECTIONS:
                     await this.initControllerIfNeeded();
-                    await this.wipeCollections();
+                    await databaseCommands.wipeCollections(this);
                     break;
                 case CHOICES.GENERATE_SCHEMAS:
                     await this.initControllerIfNeeded();
-                    await this.generateSchemas();
+                    await schemaCommands.generateSchemas(this);
                     break;
                 case CHOICES.GENERATE_CONSTANTS:
                     await this.initControllerIfNeeded();
-                    await this.generateConstants();
+                    await schemaCommands.generateConstants(this);
                     break;
                 case CHOICES.IMPORT_DATA:
                     await this.initControllerIfNeeded();
-                    await this.importData();
+                    await schemaCommands.importData(this);
                     break;
                 case CHOICES.RELOAD_CONFIG:
-                    await this.initControllerIfNeeded();
-                    await this.reloadConfig();
+                    await configCommands.reloadConfigWithSessionPreservation(this);
                     break;
                 case CHOICES.UPDATE_FUNCTION_SPEC:
                     await this.initControllerIfNeeded();
-                    await this.updateFunctionSpec();
+                    await functionCommands.updateFunctionSpec(this);
                     break;
                 case CHOICES.EXIT:
                     MessageFormatter.success("Goodbye!");
@@ -158,6 +163,27 @@ export class InteractiveCLI {
             this.controller = new UtilsController(this.currentDir, directConfig);
             await this.controller.init();
         }
+        else {
+            // Extract session info from existing controller before reinitializing
+            const sessionInfo = this.controller.getSessionInfo();
+            if (sessionInfo.hasSession && directConfig) {
+                // Create enhanced directConfig with session preservation
+                const enhancedDirectConfig = {
+                    ...directConfig,
+                    sessionCookie: this.controller.sessionCookie,
+                    sessionMetadata: this.controller.sessionMetadata
+                };
+                // Reinitialize with session preservation
+                this.controller = new UtilsController(this.currentDir, enhancedDirectConfig);
+                await this.controller.init();
+            }
+            else if (directConfig) {
+                // Standard reinitialize without session
+                this.controller = new UtilsController(this.currentDir, directConfig);
+                await this.controller.init();
+            }
+            // If no directConfig provided, keep existing controller
+        }
     }
     async selectDatabases(databases, message, multiSelect = true) {
         await this.initControllerIfNeeded();
@@ -175,11 +201,7 @@ export class InteractiveCLI {
                 acc.push(db);
             }
             return acc;
-        }, [])
-            .filter((db) => {
-            const useMigrations = this.controller?.config?.useMigrations ?? true;
-            return useMigrations || db.name.toLowerCase() !== "migrations";
-        });
+        }, []);
         const hasLocalAndRemote = allDatabases.some((db) => configDatabases.some((c) => c.name === db.name)) &&
             allDatabases.some((db) => !configDatabases.some((c) => c.name === db.name));
         const choices = allDatabases
@@ -192,11 +214,7 @@ export class InteractiveCLI {
                         : " (Remote)"
                     : ""),
             value: db,
-        }))
-            .filter((db) => {
-            const useMigrations = this.controller?.config?.useMigrations ?? true;
-            return useMigrations || db.name.toLowerCase() !== "migrations";
-        });
+        }));
         const { selectedDatabases } = await inquirer.prompt([
             {
                 type: multiSelect ? "checkbox" : "list",
@@ -217,7 +235,7 @@ export class InteractiveCLI {
             Query.equal("name", database.name),
         ]);
         if (dbExists.total === 0) {
-            console.log(chalk.red(`Database "${database.name}" does not exist, using only local collection options`));
+            MessageFormatter.warning(`Database "${database.name}" does not exist, using only local collection/table options`, { prefix: "Database" });
             shouldFilterByDatabase = false;
         }
         else {
@@ -235,21 +253,75 @@ export class InteractiveCLI {
                 ...configCollections.filter((c) => !remoteCollections.some((rc) => rc.name === c.name)),
             ];
         if (shouldFilterByDatabase) {
-            allCollections = allCollections.filter((c) => c.databaseId === database.$id);
+            // Enhanced filtering for tables with optional databaseId
+            allCollections = allCollections.filter((c) => {
+                // For remote collections, they should match the selected database
+                if (remoteCollections.some((rc) => rc.name === c.name)) {
+                    return c.databaseId === database.$id;
+                }
+                // For local collections/tables:
+                // - Collections without databaseId are kept (backward compatibility)
+                // - Tables with databaseId must match the selected database
+                // - Tables without databaseId are kept (fallback for misconfigured tables)
+                if (!c.databaseId)
+                    return true;
+                return c.databaseId === database.$id;
+            });
         }
+        // Filter out system tables (those starting with underscore)
+        allCollections = allCollections.filter((collection) => !collection.$id.startsWith('_'));
         const hasLocalAndRemote = allCollections.some((coll) => configCollections.some((c) => c.name === coll.name)) &&
             allCollections.some((coll) => !configCollections.some((c) => c.name === coll.name));
+        // Enhanced choice display with type indicators
         const choices = allCollections
-            .sort((a, b) => a.name.localeCompare(b.name))
-            .map((collection) => ({
-            name: collection.name +
-                (hasLocalAndRemote
-                    ? configCollections.some((c) => c.name === collection.name)
-                        ? " (Local)"
-                        : " (Remote)"
-                    : ""),
-            value: collection,
-        }));
+            .sort((a, b) => {
+            // Sort by type first (collections before tables), then by name
+            const aIsTable = a._isFromTablesDir || false;
+            const bIsTable = b._isFromTablesDir || false;
+            if (aIsTable !== bIsTable) {
+                return aIsTable ? 1 : -1; // Collections first, then tables
+            }
+            return a.name.localeCompare(b.name);
+        })
+            .map((collection) => {
+            const localCollection = configCollections.find((c) => c.name === collection.name);
+            const isLocal = !!localCollection;
+            const isTable = localCollection?._isFromTablesDir || collection._isFromTablesDir || false;
+            const sourceFolder = localCollection?._sourceFolder || collection._sourceFolder || 'collections';
+            let typeIndicator = '';
+            let locationIndicator = '';
+            // Type indicator
+            if (isTable) {
+                typeIndicator = chalk.cyan('[Table]');
+            }
+            else {
+                typeIndicator = chalk.green('[Collection]');
+            }
+            // Location indicator
+            if (hasLocalAndRemote) {
+                if (isLocal) {
+                    locationIndicator = chalk.gray(`(Local/${sourceFolder})`);
+                }
+                else {
+                    locationIndicator = chalk.gray('(Remote)');
+                }
+            }
+            else if (isLocal) {
+                locationIndicator = chalk.gray(`(${sourceFolder}/)`);
+            }
+            // Database indicator for tables with explicit databaseId
+            let dbIndicator = '';
+            if (isTable && collection.databaseId && shouldFilterByDatabase) {
+                const matchesCurrentDb = collection.databaseId === database.$id;
+                if (!matchesCurrentDb) {
+                    dbIndicator = chalk.yellow(` [DB: ${collection.databaseId}]`);
+                }
+            }
+            return {
+                name: `${typeIndicator} ${collection.name} ${locationIndicator}${dbIndicator}`,
+                value: collection,
+            };
+        });
         const { selectedCollections } = await inquirer.prompt([
             {
                 type: multiSelect ? "checkbox" : "list",
@@ -257,11 +329,39 @@ export class InteractiveCLI {
                 message: chalk.blue(message),
                 choices,
                 loop: true,
-                pageSize: 10,
+                pageSize: 15, // Increased page size to accommodate additional info
             },
         ]);
         return selectedCollections;
     }
+    /**
+     * Enhanced collection/table selection with better guidance for mixed scenarios
+     */
+    async selectCollectionsAndTables(database, databasesClient, message, multiSelect = true, preferLocal = false, shouldFilterByDatabase = false) {
+        const configCollections = this.getLocalCollections();
+        const collectionsCount = configCollections.filter(c => !c._isFromTablesDir).length;
+        const tablesCount = configCollections.filter(c => c._isFromTablesDir).length;
+        // Provide context about what's available
+        if (collectionsCount > 0 && tablesCount > 0) {
+            MessageFormatter.info(`\n📋 Available items for database "${database.name}":`, { prefix: "Collections" });
+            MessageFormatter.info(`   Collections: ${collectionsCount} (from collections/ folder)`, { prefix: "Collections" });
+            MessageFormatter.info(`   Tables: ${tablesCount} (from tables/ folder)`, { prefix: "Collections" });
+            if (shouldFilterByDatabase) {
+                const filteredTables = configCollections.filter(c => c._isFromTablesDir && (!c.databaseId || c.databaseId === database.$id)).length;
+                if (filteredTables !== tablesCount) {
+                    MessageFormatter.warning(`   Note: ${filteredTables}/${tablesCount} tables match this database`, { prefix: "Collections" });
+                }
+            }
+            MessageFormatter.info('', { prefix: "Collections" });
+        }
+        else if (collectionsCount > 0) {
+            MessageFormatter.info(`📁 ${collectionsCount} collections available from collections/ folder\n`, { prefix: "Collections" });
+        }
+        else if (tablesCount > 0) {
+            MessageFormatter.info(`📊 ${tablesCount} tables available from tables/ folder\n`, { prefix: "Collections" });
+        }
+        return this.selectCollections(database, databasesClient, message, multiSelect, preferLocal, shouldFilterByDatabase);
+    }
     getTemplateDefaults(template) {
         const defaults = {
             "typescript-node": {
@@ -270,6 +370,12 @@ export class InteractiveCLI {
                 commands: "npm install && npm run build",
                 specification: "s-0.5vcpu-512mb",
             },
+            "hono-typescript": {
+                runtime: "node-21.0",
+                entrypoint: "src/index.ts",
+                commands: "npm install && npm run build",
+                specification: "s-0.5vcpu-512mb",
+            },
             "uv": {
                 runtime: "python-3.12",
                 entrypoint: "src/index.py",
@@ -290,98 +396,6 @@ export class InteractiveCLI {
             specification: "s-0.5vcpu-512mb",
         };
     }
-    async createFunction() {
-        const { name } = await inquirer.prompt([
-            {
-                type: "input",
-                name: "name",
-                message: "Function name:",
-                validate: (input) => input.length > 0,
-            },
-        ]);
-        const { template } = await inquirer.prompt([
-            {
-                type: "list",
-                name: "template",
-                message: "Select a template:",
-                choices: [
-                    { name: "TypeScript Node.js", value: "typescript-node" },
-                    { name: "Python with UV", value: "uv" },
-                    { name: "Count Documents in Collection", value: "count-docs-in-collection" },
-                    { name: "None (Empty Function)", value: "none" },
-                ],
-            },
-        ]);
-        // Get template defaults
-        const templateDefaults = this.getTemplateDefaults(template);
-        const { runtime } = await inquirer.prompt([
-            {
-                type: "list",
-                name: "runtime",
-                message: "Select runtime:",
-                choices: Object.values(RuntimeSchema.Values),
-                default: templateDefaults.runtime,
-            },
-        ]);
-        const specifications = await listSpecifications(this.controller.appwriteServer);
-        const { specification } = await inquirer.prompt([
-            {
-                type: "list",
-                name: "specification",
-                message: "Select specification:",
-                choices: [
-                    { name: "None", value: undefined },
-                    ...specifications.specifications.map((s) => ({
-                        name: s.slug,
-                        value: s.slug,
-                    })),
-                ],
-                default: templateDefaults.specification,
-            },
-        ]);
-        const functionConfig = {
-            $id: ulid(),
-            name,
-            runtime,
-            events: [],
-            execute: ["any"],
-            enabled: true,
-            logging: true,
-            entrypoint: templateDefaults.entrypoint,
-            commands: templateDefaults.commands,
-            specification: specification || templateDefaults.specification,
-            scopes: [],
-            timeout: 15,
-            schedule: "",
-            installationId: "",
-            providerRepositoryId: "",
-            providerBranch: "",
-            providerSilentMode: false,
-            providerRootDirectory: "",
-            templateRepository: "",
-            templateOwner: "",
-            templateRootDirectory: "",
-        };
-        if (template !== "none") {
-            await createFunctionTemplate(template, name, "./functions");
-        }
-        // Add to in-memory config
-        if (!this.controller.config.functions) {
-            this.controller.config.functions = [];
-        }
-        this.controller.config.functions.push(functionConfig);
-        // If using YAML config, also add to YAML file
-        const yamlConfigPath = findYamlConfig(this.currentDir);
-        if (yamlConfigPath) {
-            try {
-                await addFunctionToYamlConfig(yamlConfigPath, functionConfig);
-            }
-            catch (error) {
-                MessageFormatter.warning(`Function created but failed to update YAML config: ${error instanceof Error ? error.message : error}`, { prefix: "Functions" });
-            }
-        }
-        MessageFormatter.success("Function created successfully!", { prefix: "Functions" });
-    }
     async findFunctionInSubdirectories(basePaths, functionName) {
         // Common locations to check first
         const commonPaths = basePaths.flatMap((basePath) => [
@@ -402,7 +416,7 @@ export class InteractiveCLI {
             try {
                 const stats = await fs.promises.stat(path);
                 if (stats.isDirectory()) {
-                    console.log(chalk.green(`Found function at common location: ${path}`));
+                    MessageFormatter.success(`Found function at common location: ${path}`, { prefix: "Functions" });
                     return path;
                 }
             }
@@ -411,7 +425,7 @@ export class InteractiveCLI {
             }
         }
         // If not found in common locations, do recursive search
-        console.log(chalk.yellow("Function not found in common locations, searching subdirectories..."));
+        MessageFormatter.info("Function not found in common locations, searching subdirectories...", { prefix: "Functions" });
         const queue = [...basePaths];
         const searched = new Set();
         while (queue.length > 0) {
@@ -438,7 +452,7 @@ export class InteractiveCLI {
                         // Check if any variation of the entry name matches any variation of the function name
                         const hasMatch = [...functionNameVariations].some((fnVar) => [...entryNameVariations].includes(fnVar));
                         if (hasMatch) {
-                            console.log(chalk.green(`Found function at: ${fullPath}`));
+                            MessageFormatter.success(`Found function at: ${fullPath}`, { prefix: "Functions" });
                             return fullPath;
                         }
                         queue.push(fullPath);
@@ -446,150 +460,11 @@ export class InteractiveCLI {
                 }
             }
             catch (error) {
-                console.log(chalk.yellow(`Error reading directory ${currentPath}:`, error));
+                MessageFormatter.warning(`Error reading directory ${currentPath}: ${error}`, { prefix: "Functions" });
             }
         }
         return null;
     }
-    async deployFunction() {
-        await this.initControllerIfNeeded();
-        if (!this.controller?.config) {
-            console.log(chalk.red("Failed to initialize controller or load config"));
-            return;
-        }
-        const functions = await this.selectFunctions("Select function(s) to deploy:", true, true);
-        if (!functions?.length) {
-            console.log(chalk.red("No function selected"));
-            return;
-        }
-        for (const functionConfig of functions) {
-            if (!functionConfig) {
-                console.log(chalk.red("Invalid function configuration"));
-                return;
-            }
-            // Ensure functions array exists
-            if (!this.controller.config.functions) {
-                this.controller.config.functions = [];
-            }
-            const functionNameLower = functionConfig.name
-                .toLowerCase()
-                .replace(/\s+/g, "-");
-            // Debug logging
-            console.log(chalk.blue(`🔍 Function deployment debug:`));
-            console.log(chalk.gray(`  Function name: ${functionConfig.name}`));
-            console.log(chalk.gray(`  Function ID: ${functionConfig.$id}`));
-            console.log(chalk.gray(`  Config dirPath: ${functionConfig.dirPath || 'undefined'}`));
-            if (functionConfig.dirPath) {
-                const expandedPath = functionConfig.dirPath.startsWith('~/')
-                    ? functionConfig.dirPath.replace('~', os.homedir())
-                    : functionConfig.dirPath;
-                console.log(chalk.gray(`  Expanded dirPath: ${expandedPath}`));
-            }
-            console.log(chalk.gray(`  Appwrite folder: ${this.controller.getAppwriteFolderPath()}`));
-            console.log(chalk.gray(`  Current working dir: ${process.cwd()}`));
-            // Helper function to expand tilde in paths
-            const expandTildePath = (path) => {
-                if (path.startsWith('~/')) {
-                    return path.replace('~', os.homedir());
-                }
-                return path;
-            };
-            // Check locations in priority order:
-            const priorityLocations = [
-                // 1. Config dirPath if specified (with tilde expansion)
-                functionConfig.dirPath ? expandTildePath(functionConfig.dirPath) : undefined,
-                // 2. Appwrite config folder/functions/name
-                join(this.controller.getAppwriteFolderPath(), "functions", functionNameLower),
-                // 3. Current working directory/functions/name
-                join(process.cwd(), "functions", functionNameLower),
-                // 4. Current working directory/name
-                join(process.cwd(), functionNameLower),
-            ].filter((val) => val !== undefined); // Remove undefined entries (in case dirPath is undefined)
-            console.log(chalk.blue(`🔍 Priority locations to check:`));
-            priorityLocations.forEach((loc, i) => {
-                console.log(chalk.gray(`  ${i + 1}. ${loc}`));
-            });
-            let functionPath = null;
-            // Check each priority location
-            for (const location of priorityLocations) {
-                console.log(chalk.gray(`  Checking: ${location} - ${fs.existsSync(location) ? 'EXISTS' : 'NOT FOUND'}`));
-                if (fs.existsSync(location)) {
-                    console.log(chalk.green(`✅ Found function at: ${location}`));
-                    functionPath = location;
-                    break;
-                }
-            }
-            // If not found in priority locations, do a broader search
-            if (!functionPath) {
-                console.log(chalk.yellow(`Function not found in primary locations, searching subdirectories...`));
-                // Search in both appwrite config directory and current working directory
-                functionPath = await this.findFunctionInSubdirectories([this.controller.getAppwriteFolderPath(), process.cwd()], functionNameLower);
-            }
-            if (!functionPath) {
-                const { shouldDownload } = await inquirer.prompt([
-                    {
-                        type: "confirm",
-                        name: "shouldDownload",
-                        message: "Function not found locally. Would you like to download the latest deployment?",
-                        default: false,
-                    },
-                ]);
-                if (shouldDownload) {
-                    try {
-                        console.log(chalk.blue("Downloading latest deployment..."));
-                        const { path: downloadedPath, function: remoteFunction } = await downloadLatestFunctionDeployment(this.controller.appwriteServer, functionConfig.$id, join(this.controller.getAppwriteFolderPath(), "functions"));
-                        console.log(chalk.green(`✨ Function downloaded to ${downloadedPath}`));
-                        functionPath = downloadedPath;
-                        functionConfig.dirPath = downloadedPath;
-                        const existingIndex = this.controller.config.functions.findIndex((f) => f?.$id === remoteFunction.$id);
-                        if (existingIndex >= 0) {
-                            this.controller.config.functions[existingIndex].dirPath =
-                                downloadedPath;
-                        }
-                        await this.controller.reloadConfig();
-                    }
-                    catch (error) {
-                        console.error(chalk.red("Failed to download function deployment:"), error);
-                        return;
-                    }
-                }
-                else {
-                    console.log(chalk.red(`Function ${functionConfig.name} not found locally. Cannot deploy.`));
-                    return;
-                }
-            }
-            if (!this.controller.appwriteServer) {
-                console.log(chalk.red("Appwrite server not initialized"));
-                return;
-            }
-            try {
-                await deployLocalFunction(this.controller.appwriteServer, functionConfig.name, {
-                    ...functionConfig,
-                    dirPath: functionPath,
-                }, functionPath);
-                MessageFormatter.success("Function deployed successfully!", { prefix: "Functions" });
-            }
-            catch (error) {
-                console.error(chalk.red("Failed to deploy function:"), error);
-            }
-        }
-    }
-    async deleteFunction() {
-        const functions = await this.selectFunctions("Select functions to delete:", true, false);
-        if (!functions.length) {
-            console.log(chalk.red("No functions selected"));
-            return;
-        }
-        for (const func of functions) {
-            try {
-                await deleteFunction(this.controller.appwriteServer, func.$id);
-                console.log(chalk.green(`✨ Function ${func.name} deleted successfully!`));
-            }
-            catch (error) {
-                console.error(chalk.red(`Failed to delete function ${func.name}:`), error);
-            }
-        }
-    }
     async selectFunctions(message, multiple = true, includeRemote = false) {
         const remoteFunctions = includeRemote
             ? await listFunctions(this.controller.appwriteServer, [
@@ -667,18 +542,6 @@ export class InteractiveCLI {
         ]);
         return selectedBuckets;
     }
-    async createCollectionConfig() {
-        const { collectionName } = await inquirer.prompt([
-            {
-                type: "input",
-                name: "collectionName",
-                message: chalk.blue("Enter the name of the collection:"),
-                validate: (input) => input.trim() !== "" || "Collection name cannot be empty.",
-            },
-        ]);
-        console.log(chalk.green(`Creating collection config file for '${collectionName}'...`));
-        createEmptyCollection(collectionName);
-    }
     async configureBuckets(config, databases) {
         const { storage } = this.controller;
         if (!storage) {
@@ -860,548 +723,6 @@ export class InteractiveCLI {
             antivirus: bucketAntivirus,
         }, bucketId.length > 0 ? bucketId : ulid());
     }
-    async syncDb() {
-        console.log(chalk.blue("Pushing local configuration to Appwrite..."));
-        const databases = await this.selectDatabases(this.getLocalDatabases(), chalk.blue("Select local databases to push:"), true);
-        if (!databases.length) {
-            console.log(chalk.yellow("No databases selected. Skipping database sync."));
-            return;
-        }
-        const collections = await this.selectCollections(databases[0], this.controller.database, chalk.blue("Select local collections to push:"), true, true, // prefer local
-        true // filter by selected database
-        );
-        const { syncFunctions } = await inquirer.prompt([
-            {
-                type: "confirm",
-                name: "syncFunctions",
-                message: "Do you want to push local functions to remote?",
-                default: false,
-            },
-        ]);
-        try {
-            // First sync databases and collections
-            await this.controller.syncDb(databases, collections);
-            console.log(chalk.green("Database and collections pushed successfully"));
-            // Then handle functions if requested
-            if (syncFunctions && this.controller.config?.functions?.length) {
-                const functions = await this.selectFunctions(chalk.blue("Select local functions to push:"), true, true // prefer local
-                );
-                for (const func of functions) {
-                    try {
-                        await this.controller.deployFunction(func.name);
-                        console.log(chalk.green(`Function ${func.name} deployed successfully`));
-                    }
-                    catch (error) {
-                        console.error(chalk.red(`Failed to deploy function ${func.name}:`), error);
-                    }
-                }
-            }
-            console.log(chalk.green("Local configuration push completed successfully!"));
-        }
-        catch (error) {
-            console.error(chalk.red("Failed to push local configuration:"), error);
-            throw error;
-        }
-    }
-    async synchronizeConfigurations() {
-        console.log(chalk.blue("Synchronizing configurations..."));
-        await this.controller.init();
-        // Sync databases, collections, and buckets
-        const { syncDatabases } = await inquirer.prompt([
-            {
-                type: "confirm",
-                name: "syncDatabases",
-                message: "Do you want to synchronize databases, collections, and their buckets?",
-                default: true,
-            },
-        ]);
-        if (syncDatabases) {
-            const remoteDatabases = await fetchAllDatabases(this.controller.database);
-            // Use the controller's synchronizeConfigurations method which handles collections properly
-            console.log(chalk.blue("Pulling collections and generating collection files..."));
-            await this.controller.synchronizeConfigurations(remoteDatabases);
-            // Also configure buckets for any new databases
-            const localDatabases = this.controller.config?.databases || [];
-            const updatedConfig = await this.configureBuckets({
-                ...this.controller.config,
-                databases: [
-                    ...localDatabases,
-                    ...remoteDatabases.filter((rd) => !localDatabases.some((ld) => ld.name === rd.name)),
-                ],
-            });
-            this.controller.config = updatedConfig;
-        }
-        // Then sync functions
-        const { syncFunctions } = await inquirer.prompt([
-            {
-                type: "confirm",
-                name: "syncFunctions",
-                message: "Do you want to synchronize functions?",
-                default: true,
-            },
-        ]);
-        if (syncFunctions) {
-            const remoteFunctions = await this.controller.listAllFunctions();
-            const localFunctions = this.controller.config?.functions || [];
-            const allFunctions = [
-                ...remoteFunctions,
-                ...localFunctions.filter((f) => !remoteFunctions.some((rf) => rf.$id === f.$id)),
-            ];
-            for (const func of allFunctions) {
-                const hasLocal = localFunctions.some((lf) => lf.$id === func.$id);
-                const hasRemote = remoteFunctions.some((rf) => rf.$id === func.$id);
-                if (hasLocal && hasRemote) {
-                    // First try to find the function locally
-                    let functionPath = join(this.controller.getAppwriteFolderPath(), "functions", func.name);
-                    if (!fs.existsSync(functionPath)) {
-                        console.log(chalk.yellow(`Function not found in primary location, searching subdirectories...`));
-                        const foundPath = await this.findFunctionInSubdirectories([this.controller.getAppwriteFolderPath(), process.cwd()], func.name);
-                        if (foundPath) {
-                            console.log(chalk.green(`Found function at: ${foundPath}`));
-                            functionPath = foundPath;
-                        }
-                    }
-                    const { preference } = await inquirer.prompt([
-                        {
-                            type: "list",
-                            name: "preference",
-                            message: `Function "${func.name}" ${functionPath ? "found at " + functionPath : "not found locally"}. What would you like to do?`,
-                            choices: [
-                                ...(functionPath
-                                    ? [
-                                        {
-                                            name: "Keep local version (deploy to remote)",
-                                            value: "local",
-                                        },
-                                    ]
-                                    : []),
-                                { name: "Use remote version (download)", value: "remote" },
-                                { name: "Update config only", value: "config" },
-                                { name: "Skip this function", value: "skip" },
-                            ],
-                        },
-                    ]);
-                    if (preference === "local" && functionPath) {
-                        await this.controller.deployFunction(func.name);
-                    }
-                    else if (preference === "remote") {
-                        await downloadLatestFunctionDeployment(this.controller.appwriteServer, func.$id, join(this.controller.getAppwriteFolderPath(), "functions"));
-                    }
-                    else if (preference === "config") {
-                        const remoteFunction = await getFunction(this.controller.appwriteServer, func.$id);
-                        const newFunction = {
-                            $id: remoteFunction.$id,
-                            name: remoteFunction.name,
-                            runtime: remoteFunction.runtime,
-                            execute: remoteFunction.execute || [],
-                            events: remoteFunction.events || [],
-                            schedule: remoteFunction.schedule || "",
-                            timeout: remoteFunction.timeout || 15,
-                            enabled: remoteFunction.enabled !== false,
-                            logging: remoteFunction.logging !== false,
-                            entrypoint: remoteFunction.entrypoint || "src/index.ts",
-                            commands: remoteFunction.commands || "npm install",
-                            scopes: (remoteFunction.scopes || []),
-                            installationId: remoteFunction.installationId,
-                            providerRepositoryId: remoteFunction.providerRepositoryId,
-                            providerBranch: remoteFunction.providerBranch,
-                            providerSilentMode: remoteFunction.providerSilentMode,
-                            providerRootDirectory: remoteFunction.providerRootDirectory,
-                            specification: remoteFunction.specification,
-                        };
-                        const existingIndex = this.controller.config.functions.findIndex((f) => f.$id === remoteFunction.$id);
-                        if (existingIndex >= 0) {
-                            this.controller.config.functions[existingIndex] = newFunction;
-                        }
-                        else {
-                            this.controller.config.functions.push(newFunction);
-                        }
-                        console.log(chalk.green(`Updated config for function: ${func.name}`));
-                    }
-                }
-                else if (hasLocal) {
-                    // Similar check for local-only functions
-                    let functionPath = join(this.controller.getAppwriteFolderPath(), "functions", func.name);
-                    if (!fs.existsSync(functionPath)) {
-                        const foundPath = await this.findFunctionInSubdirectories([this.controller.getAppwriteFolderPath(), process.cwd()], func.name);
-                        if (foundPath) {
-                            functionPath = foundPath;
-                        }
-                    }
-                    const { action } = await inquirer.prompt([
-                        {
-                            type: "list",
-                            name: "action",
-                            message: `Function "${func.name}" ${functionPath ? "found at " + functionPath : "not found locally"}. What would you like to do?`,
-                            choices: [
-                                ...(functionPath
-                                    ? [
-                                        {
-                                            name: "Deploy to remote",
-                                            value: "deploy",
-                                        },
-                                    ]
-                                    : []),
-                                { name: "Skip this function", value: "skip" },
-                            ],
-                        },
-                    ]);
-                    if (action === "deploy" && functionPath) {
-                        await this.controller.deployFunction(func.name);
-                    }
-                }
-                else if (hasRemote) {
-                    const { action } = await inquirer.prompt([
-                        {
-                            type: "list",
-                            name: "action",
-                            message: `Function "${func.name}" exists only remotely. What would you like to do?`,
-                            choices: [
-                                { name: "Update config only", value: "config" },
-                                { name: "Download locally", value: "download" },
-                                { name: "Skip this function", value: "skip" },
-                            ],
-                        },
-                    ]);
-                    if (action === "download") {
-                        await downloadLatestFunctionDeployment(this.controller.appwriteServer, func.$id, join(this.controller.getAppwriteFolderPath(), "functions"));
-                    }
-                    else if (action === "config") {
-                        const remoteFunction = await getFunction(this.controller.appwriteServer, func.$id);
-                        const newFunction = {
-                            $id: remoteFunction.$id,
-                            name: remoteFunction.name,
-                            runtime: remoteFunction.runtime,
-                            execute: remoteFunction.execute || [],
-                            events: remoteFunction.events || [],
-                            schedule: remoteFunction.schedule || "",
-                            timeout: remoteFunction.timeout || 15,
-                            enabled: remoteFunction.enabled !== false,
-                            logging: remoteFunction.logging !== false,
-                            entrypoint: remoteFunction.entrypoint || "src/index.ts",
-                            commands: remoteFunction.commands || "npm install",
-                            scopes: (remoteFunction.scopes || []),
-                            installationId: remoteFunction.installationId,
-                            providerRepositoryId: remoteFunction.providerRepositoryId,
-                            providerBranch: remoteFunction.providerBranch,
-                            providerSilentMode: remoteFunction.providerSilentMode,
-                            providerRootDirectory: remoteFunction.providerRootDirectory,
-                            specification: remoteFunction.specification,
-                        };
-                        this.controller.config.functions =
-                            this.controller.config.functions || [];
-                        this.controller.config.functions.push(newFunction);
-                        console.log(chalk.green(`Added config for remote function: ${func.name}`));
-                    }
-                }
-            }
-            // Schema generation and collection file writing is handled by controller.synchronizeConfigurations()
-        }
-        console.log(chalk.green("✨ Configurations synchronized successfully!"));
-    }
-    async backupDatabase() {
-        if (!this.controller.database) {
-            throw new Error("Database is not initialized, is the config file correct & created?");
-        }
-        const databases = await fetchAllDatabases(this.controller.database);
-        const selectedDatabases = await this.selectDatabases(databases, "Select databases to backup:");
-        for (const db of selectedDatabases) {
-            console.log(chalk.yellow(`Backing up database: ${db.name}`));
-            await this.controller.backupDatabase(db);
-        }
-        MessageFormatter.success("Database backup completed", { prefix: "Backup" });
-    }
-    async wipeDatabase() {
-        if (!this.controller.database || !this.controller.storage) {
-            throw new Error("Database or Storage is not initialized, is the config file correct & created?");
-        }
-        const databases = await fetchAllDatabases(this.controller.database);
-        const storage = await listBuckets(this.controller.storage);
-        const selectedDatabases = await this.selectDatabases(databases, "Select databases to wipe:");
-        const { selectedStorage } = await inquirer.prompt([
-            {
-                type: "checkbox",
-                name: "selectedStorage",
-                message: "Select storage buckets to wipe:",
-                choices: storage.buckets.map((s) => ({ name: s.name, value: s.$id })),
-            },
-        ]);
-        const { wipeUsers } = await inquirer.prompt([
-            {
-                type: "confirm",
-                name: "wipeUsers",
-                message: "Do you want to wipe users as well?",
-                default: false,
-            },
-        ]);
-        const databaseNames = selectedDatabases.map(db => db.name);
-        const confirmed = await ConfirmationDialogs.confirmDatabaseWipe(databaseNames, {
-            includeStorage: selectedStorage.length > 0,
-            includeUsers: wipeUsers
-        });
-        if (confirmed) {
-            MessageFormatter.info("Starting wipe operation...", { prefix: "Wipe" });
-            for (const db of selectedDatabases) {
-                await this.controller.wipeDatabase(db);
-            }
-            for (const bucketId of selectedStorage) {
-                await this.controller.wipeDocumentStorage(bucketId);
-            }
-            if (wipeUsers) {
-                await this.controller.wipeUsers();
-            }
-            MessageFormatter.success("Wipe operation completed", { prefix: "Wipe" });
-        }
-        else {
-            MessageFormatter.info("Wipe operation cancelled", { prefix: "Wipe" });
-        }
-    }
-    async wipeCollections() {
-        if (!this.controller.database) {
-            throw new Error("Database is not initialized, is the config file correct & created?");
-        }
-        const databases = await fetchAllDatabases(this.controller.database);
-        const selectedDatabases = await this.selectDatabases(databases, "Select the database(s) containing the collections to wipe:", true);
-        for (const database of selectedDatabases) {
-            const collections = await this.selectCollections(database, this.controller.database, `Select collections to wipe from ${database.name}:`, true, undefined, true);
-            const collectionNames = collections.map(c => c.name);
-            const confirmed = await ConfirmationDialogs.confirmCollectionWipe(database.name, collectionNames);
-            if (confirmed) {
-                MessageFormatter.info(`Wiping selected collections from ${database.name}...`, { prefix: "Wipe" });
-                for (const collection of collections) {
-                    await this.controller.wipeCollection(database, collection);
-                    MessageFormatter.success(`Collection ${collection.name} wiped successfully`, { prefix: "Wipe" });
-                }
-            }
-            else {
-                MessageFormatter.info(`Wipe operation cancelled for ${database.name}`, { prefix: "Wipe" });
-            }
-        }
-        MessageFormatter.success("Wipe collections operation completed", { prefix: "Wipe" });
-    }
-    async generateSchemas() {
-        console.log(chalk.yellow("Generating schemas..."));
-        // Prompt user for schema type preference
-        const { schemaType } = await inquirer.prompt([
-            {
-                type: "list",
-                name: "schemaType",
-                message: "What type of schemas would you like to generate?",
-                choices: [
-                    { name: "TypeScript (Zod) schemas", value: "zod" },
-                    { name: "JSON schemas", value: "json" },
-                    { name: "Both TypeScript and JSON schemas", value: "both" },
-                ],
-                default: "both",
-            },
-        ]);
-        // Get the config folder path (where the config file is located)
-        const configFolderPath = this.controller.getAppwriteFolderPath();
-        if (!configFolderPath) {
-            MessageFormatter.error("Failed to get config folder path", undefined, { prefix: "Schemas" });
-            return;
-        }
-        // Create SchemaGenerator with the correct base path and generate schemas
-        const schemaGenerator = new SchemaGenerator(this.controller.config, configFolderPath);
-        schemaGenerator.generateSchemas({ format: schemaType, verbose: true });
-        MessageFormatter.success("Schema generation completed", { prefix: "Schemas" });
-    }
-    async generateConstants() {
-        console.log(chalk.yellow("Generating cross-language constants..."));
-        if (!this.controller?.config) {
-            MessageFormatter.error("No configuration found", undefined, { prefix: "Constants" });
-            return;
-        }
-        // Prompt for languages
-        const { languages } = await inquirer.prompt([
-            {
-                type: "checkbox",
-                name: "languages",
-                message: "Select languages for constants generation:",
-                choices: [
-                    { name: "TypeScript", value: "typescript", checked: true },
-                    { name: "JavaScript", value: "javascript" },
-                    { name: "Python", value: "python" },
-                    { name: "PHP", value: "php" },
-                    { name: "Dart", value: "dart" },
-                    { name: "JSON", value: "json" },
-                    { name: "Environment Variables", value: "env" },
-                ],
-                validate: (input) => {
-                    if (input.length === 0) {
-                        return "Please select at least one language";
-                    }
-                    return true;
-                },
-            },
-        ]);
-        // Determine default output directory based on config location
-        const configPath = this.controller.getAppwriteFolderPath();
-        const defaultOutputDir = configPath
-            ? path.join(configPath, "constants")
-            : path.join(process.cwd(), "constants");
-        // Prompt for output directory
-        const { outputDir } = await inquirer.prompt([
-            {
-                type: "input",
-                name: "outputDir",
-                message: "Output directory for constants files:",
-                default: defaultOutputDir,
-                validate: (input) => {
-                    if (!input.trim()) {
-                        return "Output directory cannot be empty";
-                    }
-                    return true;
-                },
-            },
-        ]);
-        try {
-            const { ConstantsGenerator } = await import("./utils/constantsGenerator.js");
-            const generator = new ConstantsGenerator(this.controller.config);
-            MessageFormatter.info(`Generating constants for: ${languages.join(", ")}`, { prefix: "Constants" });
-            await generator.generateFiles(languages, outputDir);
-            MessageFormatter.success(`Constants generated in ${outputDir}`, { prefix: "Constants" });
-        }
-        catch (error) {
-            MessageFormatter.error("Failed to generate constants", error instanceof Error ? error : new Error(String(error)), { prefix: "Constants" });
-        }
-    }
-    async importData() {
-        console.log(chalk.yellow("Importing data..."));
-        const { doBackup } = await inquirer.prompt([
-            {
-                type: "confirm",
-                name: "doBackup",
-                message: "Do you want to perform a backup before importing?",
-                default: true,
-            },
-        ]);
-        const databases = await this.selectDatabases(await fetchAllDatabases(this.controller.database), "Select databases to import data into:", true);
-        const collections = await this.selectCollections(databases[0], this.controller.database, "Select collections to import data into (leave empty for all):", true);
-        const { shouldWriteFile } = await inquirer.prompt([
-            {
-                type: "confirm",
-                name: "shouldWriteFile",
-                message: "Do you want to write the imported data to a file?",
-                default: false,
-            },
-        ]);
-        const options = {
-            databases,
-            collections: collections.map((c) => c.name),
-            doBackup,
-            importData: true,
-            shouldWriteFile,
-        };
-        try {
-            await this.controller.importData(options);
-            console.log(chalk.green("Data import completed successfully."));
-        }
-        catch (error) {
-            console.error(chalk.red("Error importing data:"), error);
-        }
-    }
-    async transferData() {
-        if (!this.controller.database) {
-            throw new Error("Database is not initialized, is the config file correct & created?");
-        }
-        const { isRemote } = await inquirer.prompt([
-            {
-                type: "confirm",
-                name: "isRemote",
-                message: "Is this a remote transfer?",
-                default: false,
-            },
-        ]);
-        let sourceClient = this.controller.database;
-        let targetClient;
-        let sourceDatabases;
-        let targetDatabases;
-        let remoteOptions;
-        if (isRemote) {
-            remoteOptions = await inquirer.prompt([
-                {
-                    type: "input",
-                    name: "transferEndpoint",
-                    message: "Enter the remote endpoint:",
-                },
-                {
-                    type: "input",
-                    name: "transferProject",
-                    message: "Enter the remote project ID:",
-                },
-                {
-                    type: "input",
-                    name: "transferKey",
-                    message: "Enter the remote API key:",
-                },
-            ]);
-            const remoteClient = getClient(remoteOptions.transferEndpoint, remoteOptions.transferProject, remoteOptions.transferKey);
-            targetClient = new Databases(remoteClient);
-            sourceDatabases = await fetchAllDatabases(sourceClient);
-            targetDatabases = await fetchAllDatabases(targetClient);
-        }
-        else {
-            targetClient = sourceClient;
-            const allDatabases = await fetchAllDatabases(sourceClient);
-            sourceDatabases = targetDatabases = allDatabases;
-        }
-        const fromDbs = await this.selectDatabases(sourceDatabases, "Select the source database:", false);
-        const fromDb = fromDbs[0];
-        if (!fromDb) {
-            throw new Error("No source database selected");
-        }
-        const availableDbs = targetDatabases.filter((db) => db.$id !== fromDb.$id);
-        const targetDbs = await this.selectDatabases(availableDbs, "Select the target database:", false);
-        const targetDb = targetDbs[0];
-        if (!targetDb) {
-            throw new Error("No target database selected");
-        }
-        const selectedCollections = await this.selectCollections(fromDb, sourceClient, "Select collections to transfer:", true, false // don't prefer local for transfers
-        );
-        const { transferStorage } = await inquirer.prompt([
-            {
-                type: "confirm",
-                name: "transferStorage",
-                message: "Do you want to transfer storage as well?",
-                default: false,
-            },
-        ]);
-        let sourceBucket, targetBucket;
-        if (transferStorage) {
-            const sourceStorage = new Storage(this.controller.appwriteServer);
-            const targetStorage = isRemote
-                ? new Storage(getClient(remoteOptions.transferEndpoint, remoteOptions.transferProject, remoteOptions.transferKey))
-                : sourceStorage;
-            const sourceBuckets = await listBuckets(sourceStorage);
-            const targetBuckets = isRemote
-                ? await listBuckets(targetStorage)
-                : sourceBuckets;
-            const sourceBucketPicked = await this.selectBuckets(sourceBuckets.buckets, "Select the source bucket:", false);
-            const targetBucketPicked = await this.selectBuckets(targetBuckets.buckets, "Select the target bucket:", false);
-            sourceBucket = sourceBucketPicked[0];
-            targetBucket = targetBucketPicked[0];
-        }
-        let transferOptions = {
-            fromDb,
-            targetDb,
-            isRemote,
-            collections: selectedCollections.length > 0
-                ? selectedCollections.map((c) => c.$id)
-                : undefined,
-            sourceBucket,
-            targetBucket,
-        };
-        if (isRemote && remoteOptions) {
-            transferOptions = {
-                ...transferOptions,
-                ...remoteOptions,
-            };
-        }
-        console.log(chalk.yellow("Transferring data..."));
-        await this.controller.transferData(transferOptions);
-        console.log(chalk.green("Data transfer completed."));
-    }
     getLocalCollections() {
         const configCollections = this.controller.config?.collections || [];
         // @ts-expect-error - appwrite invalid types
@@ -1416,6 +737,8 @@ export class InteractiveCLI {
             indexes: c.indexes || [],
             $permissions: PermissionToAppwritePermission(c.$permissions) || [],
             databaseId: c.databaseId,
+            _isFromTablesDir: c._isFromTablesDir || false,
+            _sourceFolder: c._isFromTablesDir ? 'tables' : 'collections',
         }));
     }
     getLocalDatabases() {
@@ -1428,58 +751,29 @@ export class InteractiveCLI {
             enabled: true,
         }));
     }
-    async reloadConfig() {
-        MessageFormatter.progress("Reloading configuration files...", { prefix: "Config" });
-        try {
-            await this.controller.reloadConfig();
-            MessageFormatter.success("Configuration files reloaded successfully", { prefix: "Config" });
+    /**
+     * Extract session information from current controller for preservation
+     */
+    extractSessionFromController() {
+        if (!this.controller?.config) {
+            return undefined;
         }
-        catch (error) {
-            MessageFormatter.error("Failed to reload configuration files", error instanceof Error ? error : new Error(String(error)), { prefix: "Config" });
+        const sessionInfo = this.controller.getSessionInfo();
+        const config = this.controller.config;
+        if (!config.appwriteEndpoint || !config.appwriteProject) {
+            return undefined;
         }
-    }
-    async updateFunctionSpec() {
-        const remoteFunctions = await listFunctions(this.controller.appwriteServer, [Query.limit(1000)]);
-        const localFunctions = this.getLocalFunctions();
-        const allFunctions = [
-            ...remoteFunctions.functions,
-            ...localFunctions.filter((f) => !remoteFunctions.functions.some((rf) => rf.name === f.name)),
-        ];
-        const functionsToUpdate = await inquirer.prompt([
-            {
-                type: "checkbox",
-                name: "functionId",
-                message: "Select functions to update:",
-                choices: allFunctions.map((f) => ({
-                    name: `${f.name} (${f.$id})${localFunctions.some((lf) => lf.name === f.name)
-                        ? " (Local)"
-                        : " (Remote)"}`,
-                    value: f.$id,
-                })),
-                loop: true,
-            },
-        ]);
-        const specifications = await listSpecifications(this.controller.appwriteServer);
-        const { specification } = await inquirer.prompt([
-            {
-                type: "list",
-                name: "specification",
-                message: "Select new specification:",
-                choices: specifications.specifications.map((s) => ({
-                    name: `${s.slug}`,
-                    value: s.slug,
-                })),
-            },
-        ]);
-        try {
-            for (const functionId of functionsToUpdate.functionId) {
-                await this.controller.updateFunctionSpecifications(functionId, specification);
-                console.log(chalk.green(`Successfully updated function specification to ${specification}`));
-            }
-        }
-        catch (error) {
-            console.error(chalk.red("Error updating function specification:"), error);
+        const result = {
+            appwriteEndpoint: config.appwriteEndpoint,
+            appwriteProject: config.appwriteProject,
+            appwriteKey: config.appwriteKey
+        };
+        // Add session data if available
+        if (sessionInfo.hasSession) {
+            result.sessionCookie = this.controller.sessionCookie;
+            result.sessionMetadata = this.controller.sessionMetadata;
         }
+        return result;
     }
     async detectConfigurationType() {
         try {
@@ -1524,283 +818,4 @@ export class InteractiveCLI {
             return allChoices.filter(choice => choice !== CHOICES.MIGRATE_CONFIG);
         }
     }
-    async migrateTypeScriptConfig() {
-        try {
-            MessageFormatter.info("Starting TypeScript to YAML configuration migration...", { prefix: "Migration" });
-            // Perform the migration
-            await migrateConfig(this.currentDir);
-            // Reset the detection flag
-            this.isUsingTypeScriptConfig = false;
-            // Reset the controller to pick up the new config
-            this.controller = undefined;
-            MessageFormatter.success("Migration completed successfully!", { prefix: "Migration" });
-            MessageFormatter.info("Your configuration has been migrated to the .appwrite directory structure", { prefix: "Migration" });
-            MessageFormatter.info("You can now use YAML configuration for easier management", { prefix: "Migration" });
-        }
-        catch (error) {
-            MessageFormatter.error("Migration failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Migration" });
-        }
-    }
-    async comprehensiveTransfer() {
-        MessageFormatter.info("Starting comprehensive transfer configuration...", { prefix: "Transfer" });
-        try {
-            // Initialize controller to optionally load config if available (supports both YAML and TypeScript configs)
-            await this.initControllerIfNeeded();
-            // Check if user has an appwrite config for easier setup
-            const hasAppwriteConfig = this.controller?.config?.appwriteEndpoint &&
-                this.controller?.config?.appwriteProject &&
-                this.controller?.config?.appwriteKey;
-            let sourceConfig;
-            let targetConfig;
-            if (hasAppwriteConfig) {
-                // Offer to use existing config for source
-                const { useConfigForSource } = await inquirer.prompt([
-                    {
-                        type: "confirm",
-                        name: "useConfigForSource",
-                        message: "Use your current appwriteConfig as the source?",
-                        default: true,
-                    },
-                ]);
-                if (useConfigForSource) {
-                    sourceConfig = {
-                        sourceEndpoint: this.controller.config.appwriteEndpoint,
-                        sourceProject: this.controller.config.appwriteProject,
-                        sourceKey: this.controller.config.appwriteKey,
-                    };
-                    MessageFormatter.info(`Using config source: ${sourceConfig.sourceEndpoint}`, { prefix: "Transfer" });
-                }
-                else {
-                    // Get source configuration manually
-                    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",
-                        },
-                    ]);
-                }
-                // Offer to use existing config for target
-                const { useConfigForTarget } = await inquirer.prompt([
-                    {
-                        type: "confirm",
-                        name: "useConfigForTarget",
-                        message: "Use your current appwriteConfig as the target?",
-                        default: false,
-                    },
-                ]);
-                if (useConfigForTarget) {
-                    targetConfig = {
-                        targetEndpoint: this.controller.config.appwriteEndpoint,
-                        targetProject: this.controller.config.appwriteProject,
-                        targetKey: this.controller.config.appwriteKey,
-                    };
-                    MessageFormatter.info(`Using config target: ${targetConfig.targetEndpoint}`, { prefix: "Transfer" });
-                }
-                else {
-                    // Get target configuration manually
-                    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",
-                        },
-                    ]);
-                }
-            }
-            else {
-                // No appwrite config found, get both configurations manually
-                MessageFormatter.info("No appwriteConfig found, please enter source and target configurations manually", { prefix: "Transfer" });
-                // Get source configuration
-                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
-                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: "👥 Teams", value: "teams", 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;
-            }
-            // Password preservation information
-            if (transferOptions.transferTypes.includes("users") && !transferOptions.dryRun) {
-                MessageFormatter.info("User Password Transfer Information:", { prefix: "Transfer" });
-                MessageFormatter.info("✅ Users with hashed passwords (Argon2, Bcrypt, Scrypt, MD5, SHA, PHPass) will preserve their passwords", { prefix: "Transfer" });
-                MessageFormatter.info("⚠️  Users without hash information will receive temporary passwords and need to reset", { prefix: "Transfer" });
-                MessageFormatter.info("🔒 All user data (preferences, labels, verification status) will be preserved", { prefix: "Transfer" });
-                const { continueWithUsers } = await inquirer.prompt([
-                    {
-                        type: "confirm",
-                        name: "continueWithUsers",
-                        message: "Continue with user transfer?",
-                        default: true,
-                    },
-                ]);
-                if (!continueWithUsers) {
-                    // Remove users from transfer types
-                    transferOptions.transferTypes = transferOptions.transferTypes.filter((type) => type !== "users");
-                    if (transferOptions.transferTypes.length === 0) {
-                        MessageFormatter.info("No transfer types selected, cancelling", { prefix: "Transfer" });
-                        return;
-                    }
-                }
-            }
-            // Execute comprehensive transfer
-            const comprehensiveTransferOptions = {
-                sourceEndpoint: sourceConfig.sourceEndpoint,
-                sourceProject: sourceConfig.sourceProject,
-                sourceKey: sourceConfig.sourceKey,
-                targetEndpoint: targetConfig.targetEndpoint,
-                targetProject: targetConfig.targetProject,
-                targetKey: targetConfig.targetKey,
-                transferUsers: transferOptions.transferTypes.includes("users"),
-                transferTeams: transferOptions.transferTypes.includes("teams"),
-                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("Users with preserved password hashes can log in with their original passwords", { prefix: "Transfer" });
-                    MessageFormatter.info("Users with temporary passwords will need to reset their passwords", { prefix: "Transfer" });
-                }
-                if (transferOptions.transferTypes.includes("teams") && results.teams.transferred > 0) {
-                    MessageFormatter.info("Team memberships have been transferred and may require user acceptance of invitations", { prefix: "Transfer" });
-                }
-            }
-        }
-        catch (error) {
-            MessageFormatter.error("Comprehensive transfer failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Transfer" });
-        }
-    }
 }