appwrite-utils-cli 1.9.6 → 1.11.0

package/dist/interactiveCLI.js

@@ -1,898 +0,0 @@
-import inquirer from "inquirer";
-import { UtilsController } from "./utilsController.js";
-import { fetchAllCollections } from "./collections/methods.js";
-import { listBuckets, createBucket } from "./storage/methods.js";
-import { Databases, Storage, Client, Compression, Query, Functions, DatabaseType, } from "node-appwrite";
-import { PermissionToAppwritePermission, RuntimeSchema, permissionSchema, } from "appwrite-utils";
-import { ulid } from "ulidx";
-import chalk from "chalk";
-import { DateTime } from "luxon";
-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 { MessageFormatter } from "./shared/messageFormatter.js";
-import { findAppwriteConfig } from "./utils/loadConfigs.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 { storageCommands } from "./cli/commands/storageCommands.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)";
-    CHOICES["DELETE_FUNCTION"] = "\uD83D\uDDD1\uFE0F Delete function";
-    CHOICES["SETUP_DIRS_FILES"] = "\uD83D\uDCC1 Setup directories and files";
-    CHOICES["SETUP_DIRS_FILES_WITH_EXAMPLE_DATA"] = "\uD83D\uDCC1\u2728 Setup directories and files with example data";
-    CHOICES["SYNC_DB"] = "\u2B06\uFE0F Push local config to Appwrite";
-    CHOICES["SYNCHRONIZE_CONFIGURATIONS"] = "\uD83D\uDD04 Synchronize configurations - Pull from Appwrite and write to local config";
-    CHOICES["TRANSFER_DATA"] = "\uD83D\uDCE6 Transfer data";
-    CHOICES["COMPREHENSIVE_TRANSFER"] = "\uD83D\uDE80 Comprehensive transfer (users \u2192 databases \u2192 buckets \u2192 functions)";
-    CHOICES["BACKUP_DATABASE"] = "\uD83D\uDCBE Backup database";
-    CHOICES["WIPE_DATABASE"] = "\uD83E\uDDF9 Wipe database";
-    CHOICES["WIPE_COLLECTIONS"] = "\uD83E\uDDF9 Wipe collections";
-    CHOICES["GENERATE_SCHEMAS"] = "\uD83C\uDFD7\uFE0F Generate schemas";
-    CHOICES["GENERATE_CONSTANTS"] = "\uD83D\uDCCB Generate cross-language constants (TypeScript, Python, PHP, Dart, etc.)";
-    CHOICES["IMPORT_DATA"] = "\uD83D\uDCE5 Import data";
-    CHOICES["RELOAD_CONFIG"] = "\uD83D\uDD04 Reload configuration files";
-    CHOICES["UPDATE_FUNCTION_SPEC"] = "\u2699\uFE0F Update function specifications";
-    CHOICES["MANAGE_BUCKETS"] = "\uD83E\uDEA3 Manage storage buckets";
-    CHOICES["EXIT"] = "\uD83D\uDC4B Exit";
-})(CHOICES || (CHOICES = {}));
-export class InteractiveCLI {
-    currentDir;
-    controller;
-    isUsingTypeScriptConfig = false;
-    lastSelectedCollectionIds = [];
-    constructor(currentDir) {
-        this.currentDir = currentDir;
-    }
-    async run() {
-        MessageFormatter.banner("Appwrite Utils CLI", "Welcome to Appwrite Utils CLI Tool by Zach Handley");
-        MessageFormatter.info("For more information, visit https://github.com/zachhandley/AppwriteUtils");
-        // Detect configuration type
-        try {
-            await this.detectConfigurationType();
-        }
-        catch (error) {
-            // Continue if detection fails
-            this.isUsingTypeScriptConfig = false;
-        }
-        while (true) {
-            // Build choices array dynamically based on config type
-            const choices = this.buildChoicesList();
-            const { action } = await inquirer.prompt([
-                {
-                    type: "list",
-                    name: "action",
-                    message: chalk.yellow("What would you like to do?"),
-                    choices,
-                },
-            ]);
-            switch (action) {
-                case CHOICES.MIGRATE_CONFIG:
-                    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 configCommands.createCollectionConfig(this);
-                    break;
-                case CHOICES.CREATE_FUNCTION:
-                    await this.initControllerIfNeeded();
-                    await functionCommands.createFunction(this);
-                    break;
-                case CHOICES.DEPLOY_FUNCTION:
-                    await this.initControllerIfNeeded();
-                    await functionCommands.deployFunction(this);
-                    break;
-                case CHOICES.DELETE_FUNCTION:
-                    await this.initControllerIfNeeded();
-                    await functionCommands.deleteFunction(this);
-                    break;
-                case CHOICES.SETUP_DIRS_FILES:
-                    await schemaCommands.setupDirsFiles(this, false);
-                    break;
-                case CHOICES.SETUP_DIRS_FILES_WITH_EXAMPLE_DATA:
-                    await schemaCommands.setupDirsFiles(this, true);
-                    break;
-                case CHOICES.SYNCHRONIZE_CONFIGURATIONS:
-                    await this.initControllerIfNeeded();
-                    await databaseCommands.synchronizeConfigurations(this);
-                    break;
-                case CHOICES.SYNC_DB:
-                    await this.initControllerIfNeeded();
-                    await databaseCommands.syncDb(this);
-                    break;
-                case CHOICES.TRANSFER_DATA:
-                    await this.initControllerIfNeeded();
-                    await transferCommands.transferData(this);
-                    break;
-                case CHOICES.COMPREHENSIVE_TRANSFER:
-                    await transferCommands.comprehensiveTransfer(this);
-                    break;
-                case CHOICES.BACKUP_DATABASE:
-                    await this.initControllerIfNeeded();
-                    await databaseCommands.backupDatabase(this);
-                    break;
-                case CHOICES.WIPE_DATABASE:
-                    await this.initControllerIfNeeded();
-                    await databaseCommands.wipeDatabase(this);
-                    break;
-                case CHOICES.WIPE_COLLECTIONS:
-                    await this.initControllerIfNeeded();
-                    await databaseCommands.wipeCollections(this);
-                    break;
-                case CHOICES.GENERATE_SCHEMAS:
-                    await this.initControllerIfNeeded();
-                    await schemaCommands.generateSchemas(this);
-                    break;
-                case CHOICES.GENERATE_CONSTANTS:
-                    await this.initControllerIfNeeded();
-                    await schemaCommands.generateConstants(this);
-                    break;
-                case CHOICES.IMPORT_DATA:
-                    await this.initControllerIfNeeded();
-                    await schemaCommands.importData(this);
-                    break;
-                case CHOICES.RELOAD_CONFIG:
-                    await configCommands.reloadConfigWithSessionPreservation(this);
-                    break;
-                case CHOICES.UPDATE_FUNCTION_SPEC:
-                    await this.initControllerIfNeeded();
-                    await functionCommands.updateFunctionSpec(this);
-                    break;
-                case CHOICES.MANAGE_BUCKETS:
-                    await this.manageBuckets();
-                    break;
-                case CHOICES.EXIT:
-                    MessageFormatter.success("Goodbye!");
-                    process.exit(0);
-            }
-        }
-    }
-    async initControllerIfNeeded(directConfig) {
-        if (!this.controller) {
-            this.controller = UtilsController.getInstance(this.currentDir, directConfig);
-            await this.controller.init();
-        }
-        else {
-            // Extract session info from existing controller before reinitializing
-            const sessionInfo = await 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
-                UtilsController.clearInstance();
-                this.controller = UtilsController.getInstance(this.currentDir, enhancedDirectConfig);
-                await this.controller.init();
-            }
-            else if (directConfig) {
-                // Standard reinitialize without session
-                UtilsController.clearInstance();
-                this.controller = UtilsController.getInstance(this.currentDir, directConfig);
-                await this.controller.init();
-            }
-            // If no directConfig provided, keep existing controller
-        }
-    }
-    async manageBuckets() {
-        await this.initControllerIfNeeded();
-        while (true) {
-            const { action } = await inquirer.prompt([
-                {
-                    type: 'list',
-                    name: 'action',
-                    message: chalk.blue('Bucket management'),
-                    choices: [
-                        { name: 'Create bucket', value: 'create' },
-                        { name: 'Delete buckets', value: 'delete' },
-                        { name: 'Back', value: 'back' },
-                    ],
-                },
-            ]);
-            if (action === 'back')
-                break;
-            if (action === 'create') {
-                await storageCommands.createBucket(this);
-            }
-            else if (action === 'delete') {
-                await storageCommands.deleteBuckets(this);
-            }
-        }
-    }
-    async selectDatabases(databases, message, multiSelect = true) {
-        await this.initControllerIfNeeded();
-        const configDatabases = this.getLocalDatabases();
-        const allDatabases = [...databases, ...configDatabases]
-            .reduce((acc, db) => {
-            // Local config takes precedence - if a database with same name or ID exists, use local version
-            const existingIndex = acc.findIndex((d) => d.name === db.name || d.$id === db.$id);
-            if (existingIndex >= 0) {
-                if (configDatabases.some((cdb) => cdb.name === db.name || cdb.$id === db.$id)) {
-                    acc[existingIndex] = db; // Replace with local version
-                }
-            }
-            else {
-                acc.push(db);
-            }
-            return acc;
-        }, []);
-        const hasLocalAndRemote = allDatabases.some((db) => configDatabases.some((c) => c.name === db.name || c.$id === db.$id)) &&
-            allDatabases.some((db) => !configDatabases.some((c) => c.name === db.name || c.$id === db.$id));
-        const choices = allDatabases
-            .sort((a, b) => a.name.localeCompare(b.name))
-            .map((db) => ({
-            name: db.name +
-                (hasLocalAndRemote
-                    ? configDatabases.some((c) => c.name === db.name || c.$id === db.$id)
-                        ? " (Local)"
-                        : " (Remote)"
-                    : ""),
-            value: db,
-        }));
-        const { selectedDatabases } = await inquirer.prompt([
-            {
-                type: multiSelect ? "checkbox" : "list",
-                name: "selectedDatabases",
-                message: chalk.blue(message),
-                choices,
-                loop: true,
-                pageSize: 10,
-            },
-        ]);
-        return selectedDatabases;
-    }
-    async selectCollections(database, databasesClient, message, multiSelect = true, preferLocal = false, shouldFilterByDatabase = false) {
-        await this.initControllerIfNeeded();
-        const configCollections = this.getLocalCollections();
-        let remoteCollections = [];
-        const dbExists = await databasesClient.list([
-            Query.equal("name", database.name),
-        ]);
-        if (dbExists.total === 0) {
-            MessageFormatter.warning(`Database "${database.name}" does not exist, using only local collection/table options`, { prefix: "Database" });
-            shouldFilterByDatabase = false;
-        }
-        else {
-            remoteCollections = await fetchAllCollections(database.$id, databasesClient);
-        }
-        let allCollections = preferLocal
-            ? remoteCollections.reduce((acc, remoteCollection) => {
-                if (!acc.some((c) => c.name === remoteCollection.name || c.$id === remoteCollection.$id)) {
-                    acc.push(remoteCollection);
-                }
-                return acc;
-            }, [...configCollections])
-            : [
-                ...remoteCollections,
-                ...configCollections.filter((c) => !remoteCollections.some((rc) => rc.name === c.name || rc.$id === c.$id)),
-            ];
-        if (shouldFilterByDatabase) {
-            // Show collections that EITHER exist in the remote database OR have matching local databaseId metadata
-            allCollections = allCollections.filter((c) => {
-                // Include if it exists remotely in this database
-                const existsInRemoteDb = remoteCollections.some((rc) => rc.name === c.name || rc.$id === c.$id);
-                // Include if local metadata claims it belongs to this database
-                const hasMatchingLocalMetadata = c.databaseId === database.$id;
-                return existsInRemoteDb || hasMatchingLocalMetadata;
-            });
-        }
-        // 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 || c.$id === coll.$id)) &&
-            allCollections.some((coll) => !configCollections.some((c) => c.name === coll.name || c.$id === coll.$id));
-        // Enhanced choice display with type indicators
-        const choices = allCollections
-            .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 || c.$id === collection.$id);
-            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",
-                name: "selectedCollections",
-                message: chalk.blue(message),
-                choices,
-                loop: true,
-                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;
-        const totalCount = collectionsCount + tablesCount;
-        // Provide context about what's available
-        if (collectionsCount > 0 && tablesCount > 0) {
-            MessageFormatter.info(`\n📋 ${totalCount} total items available:`, { prefix: "Collections" });
-            MessageFormatter.info(`   Collections: ${collectionsCount} (from collections/ folder)`, { prefix: "Collections" });
-            MessageFormatter.info(`   Tables: ${tablesCount} (from tables/ folder)`, { prefix: "Collections" });
-        }
-        else if (collectionsCount > 0) {
-            MessageFormatter.info(`📁 ${collectionsCount} collections available from collections/ folder`, { prefix: "Collections" });
-        }
-        else if (tablesCount > 0) {
-            MessageFormatter.info(`📊 ${tablesCount} tables available from tables/ folder`, { prefix: "Collections" });
-        }
-        // Show current database context clearly before view mode selection
-        MessageFormatter.info(`DB: ${database.name}`, { prefix: "Collections" });
-        // Ask user if they want to filter by database, show all, or reuse previous selection
-        const choices = [
-            {
-                name: `Show all available collections/tables (${totalCount} total) - You can push any collection to any database`,
-                value: "all"
-            },
-            {
-                name: `Filter by database "${database.name}" - Show only related collections/tables`,
-                value: "filter"
-            }
-        ];
-        if (this.lastSelectedCollectionIds && this.lastSelectedCollectionIds.length > 0) {
-            choices.unshift({
-                name: `Use same selection as before (${this.lastSelectedCollectionIds.length} items)`,
-                value: "same"
-            });
-        }
-        const { filterChoice } = await inquirer.prompt([
-            {
-                type: "list",
-                name: "filterChoice",
-                message: chalk.blue("How would you like to view collections/tables?"),
-                choices,
-                default: choices[0]?.value || "all"
-            }
-        ]);
-        // If user wants to reuse the previous selection, map IDs to current config and return
-        if (filterChoice === "same") {
-            const map = new Map(this.getLocalCollections().map((c) => [c.$id || c.id, c]));
-            const selected = this.lastSelectedCollectionIds
-                .map((id) => map.get(id))
-                .filter((c) => !!c);
-            MessageFormatter.info(`Using same selection as previous: ${selected.length} item(s)`, { prefix: "Collections" });
-            return selected;
-        }
-        // User's choice overrides the parameter
-        const userWantsFiltering = filterChoice === "filter";
-        // Show appropriate informational message
-        if (userWantsFiltering) {
-            MessageFormatter.info(`ℹ️  Showing collections/tables related to database "${database.name}"`, { prefix: "Collections" });
-            if (tablesCount > 0) {
-                const filteredTables = configCollections.filter(c => c._isFromTablesDir && (!c.databaseId || c.databaseId === database.$id)).length;
-                if (filteredTables !== tablesCount) {
-                    MessageFormatter.info(`   ${filteredTables}/${tablesCount} tables match this database`, { prefix: "Collections" });
-                }
-            }
-        }
-        else {
-            MessageFormatter.info(`ℹ️  Showing all available collections/tables - you can push any collection to any database\n`, { prefix: "Collections" });
-        }
-        const result = await this.selectCollections(database, databasesClient, message, multiSelect, preferLocal, userWantsFiltering);
-        // Remember this selection for subsequent databases
-        this.lastSelectedCollectionIds = (result || []).map((c) => c.$id || c.id);
-        return result;
-    }
-    getTemplateDefaults(template) {
-        const defaults = {
-            "typescript-node": {
-                runtime: "node-21.0",
-                entrypoint: "src/index.ts",
-                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",
-                commands: "uv sync && uv build",
-                specification: "s-0.5vcpu-512mb",
-            },
-            "count-docs-in-collection": {
-                runtime: "node-21.0",
-                entrypoint: "src/main.ts",
-                commands: "npm install && npm run build",
-                specification: "s-1vcpu-512mb",
-            },
-        };
-        return defaults[template] || {
-            runtime: "node-21.0",
-            entrypoint: "",
-            commands: "",
-            specification: "s-0.5vcpu-512mb",
-        };
-    }
-    async findFunctionInSubdirectories(basePaths, functionName) {
-        // Common locations to check first
-        const commonPaths = basePaths.flatMap((basePath) => [
-            join(basePath, "functions", functionName),
-            join(basePath, functionName),
-            join(basePath, functionName.toLowerCase()),
-            join(basePath, functionName.toLowerCase().replace(/\s+/g, "")),
-        ]);
-        // Create different variations of the function name for comparison
-        const functionNameVariations = new Set([
-            functionName.toLowerCase(),
-            functionName.toLowerCase().replace(/\s+/g, ""),
-            functionName.toLowerCase().replace(/[^a-z0-9]/g, ""),
-            functionName.toLowerCase().replace(/[-_\s]+/g, ""),
-        ]);
-        // Check common locations first
-        for (const path of commonPaths) {
-            try {
-                const stats = await fs.promises.stat(path);
-                if (stats.isDirectory()) {
-                    MessageFormatter.success(`Found function at common location: ${path}`, { prefix: "Functions" });
-                    return path;
-                }
-            }
-            catch (error) {
-                // Path doesn't exist, continue to next
-            }
-        }
-        // If not found in common locations, do recursive search
-        MessageFormatter.info("Function not found in common locations, searching subdirectories...", { prefix: "Functions" });
-        const queue = [...basePaths];
-        const searched = new Set();
-        while (queue.length > 0) {
-            const currentPath = queue.shift();
-            if (searched.has(currentPath))
-                continue;
-            searched.add(currentPath);
-            try {
-                const entries = await fs.promises.readdir(currentPath, {
-                    withFileTypes: true,
-                });
-                for (const entry of entries) {
-                    const fullPath = join(currentPath, entry.name);
-                    // Skip node_modules and hidden directories
-                    if (entry.isDirectory() &&
-                        !entry.name.startsWith(".") &&
-                        entry.name !== "node_modules") {
-                        const entryNameVariations = new Set([
-                            entry.name.toLowerCase(),
-                            entry.name.toLowerCase().replace(/\s+/g, ""),
-                            entry.name.toLowerCase().replace(/[^a-z0-9]/g, ""),
-                            entry.name.toLowerCase().replace(/[-_\s]+/g, ""),
-                        ]);
-                        // 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) {
-                            MessageFormatter.success(`Found function at: ${fullPath}`, { prefix: "Functions" });
-                            return fullPath;
-                        }
-                        queue.push(fullPath);
-                    }
-                }
-            }
-            catch (error) {
-                MessageFormatter.warning(`Error reading directory ${currentPath}: ${error}`, { prefix: "Functions" });
-            }
-        }
-        return null;
-    }
-    async selectFunctions(message, multiple = true, includeRemote = false) {
-        const remoteFunctions = includeRemote
-            ? await listFunctions(this.controller.appwriteServer, [
-                Query.limit(1000),
-            ])
-            : { functions: [] };
-        const localFunctions = this.getLocalFunctions();
-        // Combine functions, preferring local ones
-        const allFunctions = [
-            ...localFunctions,
-            ...remoteFunctions.functions.filter((rf) => !localFunctions.some((lf) => lf.name === rf.name || lf.$id === rf.$id)),
-        ];
-        const { selectedFunctions } = await inquirer.prompt([
-            {
-                type: multiple ? "checkbox" : "list",
-                name: "selectedFunctions",
-                message,
-                choices: allFunctions.map((f) => ({
-                    name: `${f.name} (${f.$id})${localFunctions.some((lf) => lf.name === f.name || lf.$id === f.$id)
-                        ? " (Local)"
-                        : " (Remote)"}`,
-                    value: f,
-                })),
-                loop: true,
-            },
-        ]);
-        return multiple ? selectedFunctions : [selectedFunctions];
-    }
-    getLocalFunctions() {
-        const configFunctions = this.controller.config?.functions || [];
-        return configFunctions.map((f) => ({
-            $id: f.$id || ulid(),
-            $createdAt: DateTime.now().toISO(),
-            $updatedAt: DateTime.now().toISO(),
-            name: f.name,
-            runtime: f.runtime,
-            execute: f.execute || ["any"],
-            events: f.events || [],
-            schedule: f.schedule || "",
-            timeout: f.timeout || 15,
-            ignore: f.ignore,
-            enabled: f.enabled !== false,
-            logging: f.logging !== false,
-            entrypoint: f.entrypoint || "src/index.ts",
-            commands: f.commands || "npm install",
-            scopes: f.scopes || [], // Add scopes
-            path: f.dirPath || `functions/${f.name}`,
-            dirPath: f.dirPath, // Preserve original dirPath
-            installationId: f.installationId || "",
-            providerRepositoryId: f.providerRepositoryId || "",
-            providerBranch: f.providerBranch || "",
-            providerSilentMode: f.providerSilentMode || false,
-            providerRootDirectory: f.providerRootDirectory || "",
-            ...(f.specification ? { specification: f.specification } : {}),
-            ...(f.predeployCommands
-                ? { predeployCommands: f.predeployCommands }
-                : {}),
-            ...(f.deployDir ? { deployDir: f.deployDir } : {}),
-        }));
-    }
-    async selectBuckets(buckets, message, multiSelect = true) {
-        const choices = buckets.map((bucket) => ({
-            name: bucket.name,
-            value: bucket,
-        }));
-        const { selectedBuckets } = await inquirer.prompt([
-            {
-                type: multiSelect ? "checkbox" : "list",
-                name: "selectedBuckets",
-                message: chalk.blue(message),
-                choices,
-                loop: false,
-                pageSize: 10,
-            },
-        ]);
-        return selectedBuckets;
-    }
-    async configureBuckets(config, databases) {
-        const { storage } = this.controller;
-        if (!storage) {
-            throw new Error("Storage is not initialized. Is the config file correct and created?");
-        }
-        const allBuckets = await listBuckets(storage);
-        // If there are no buckets, ask to create one for each database
-        if (allBuckets.total === 0) {
-            const databasesToUse = databases ?? config.databases;
-            for (const database of databasesToUse) {
-                // If database has bucket config in local config, use that
-                const localDatabase = this.controller.config?.databases.find((db) => db.name === database.name);
-                if (localDatabase?.bucket) {
-                    database.bucket = localDatabase.bucket;
-                    continue;
-                }
-                const { wantCreateBucket } = await inquirer.prompt([
-                    {
-                        type: "confirm",
-                        name: "wantCreateBucket",
-                        message: chalk.blue(`There are no buckets. Do you want to create a bucket for the database "${database.name}"?`),
-                        default: true,
-                    },
-                ]);
-                if (wantCreateBucket) {
-                    const createdBucket = await this.createNewBucket(storage, database.name);
-                    database.bucket = {
-                        ...createdBucket,
-                        compression: createdBucket.compression,
-                    };
-                }
-            }
-            return config;
-        }
-        // Configure global buckets
-        let globalBuckets = [];
-        if (allBuckets.total > 0) {
-            globalBuckets = await this.selectBuckets(allBuckets.buckets, "Select global buckets (buckets that are not associated with any specific database):", true);
-            config.buckets = globalBuckets.map((bucket) => ({
-                $id: bucket.$id,
-                name: bucket.name,
-                enabled: bucket.enabled,
-                maximumFileSize: bucket.maximumFileSize,
-                allowedFileExtensions: bucket.allowedFileExtensions,
-                compression: bucket.compression,
-                encryption: bucket.encryption,
-                antivirus: bucket.antivirus,
-            }));
-        }
-        else {
-            config.buckets = [];
-        }
-        // Configure database-specific buckets
-        for (const database of config.databases) {
-            const { assignBucket } = await inquirer.prompt([
-                {
-                    type: "confirm",
-                    name: "assignBucket",
-                    message: `Do you want to assign or create a bucket for the database "${database.name}"?`,
-                    default: false,
-                },
-            ]);
-            if (assignBucket) {
-                const { action } = await inquirer.prompt([
-                    {
-                        type: "list",
-                        name: "action",
-                        message: `Choose an action for the database "${database.name}":`,
-                        choices: [
-                            { name: "Assign existing bucket", value: "assign" },
-                            { name: "Create new bucket", value: "create" },
-                        ],
-                    },
-                ]);
-                if (action === "assign") {
-                    const selectedBuckets = await this.selectBuckets(allBuckets.buckets.filter((b) => !globalBuckets.some((gb) => gb.$id === b.$id)), `Select a bucket for the database "${database.name}":`, false // multiSelect = false
-                    );
-                    if (selectedBuckets.length > 0) {
-                        const selectedBucket = selectedBuckets[0];
-                        database.bucket = {
-                            $id: selectedBucket.$id,
-                            name: selectedBucket.name,
-                            enabled: selectedBucket.enabled,
-                            maximumFileSize: selectedBucket.maximumFileSize,
-                            allowedFileExtensions: selectedBucket.allowedFileExtensions,
-                            compression: selectedBucket.compression,
-                            encryption: selectedBucket.encryption,
-                            antivirus: selectedBucket.antivirus,
-                            permissions: selectedBucket.$permissions.map((p) => permissionSchema.parse(p)),
-                        };
-                    }
-                }
-                else if (action === "create") {
-                    const createdBucket = await this.createNewBucket(storage, database.name);
-                    database.bucket = {
-                        ...createdBucket,
-                        compression: createdBucket.compression,
-                    };
-                }
-            }
-        }
-        return config;
-    }
-    async createNewBucket(storage, databaseName) {
-        const { bucketName, bucketEnabled, bucketMaximumFileSize, bucketAllowedFileExtensions, bucketFileSecurity, bucketCompression, bucketCompressionType, bucketEncryption, bucketAntivirus, bucketId, } = await inquirer.prompt([
-            {
-                type: "input",
-                name: "bucketName",
-                message: `Enter the name of the bucket for database "${databaseName}":`,
-                default: `${databaseName}-bucket`,
-            },
-            {
-                type: "confirm",
-                name: "bucketEnabled",
-                message: "Is the bucket enabled?",
-                default: true,
-            },
-            {
-                type: "confirm",
-                name: "bucketFileSecurity",
-                message: "Do you want to enable file security for the bucket?",
-                default: false,
-            },
-            {
-                type: "number",
-                name: "bucketMaximumFileSize",
-                message: "Enter the maximum file size for the bucket (MB):",
-                default: 1000000,
-            },
-            {
-                type: "input",
-                name: "bucketAllowedFileExtensions",
-                message: "Enter the allowed file extensions for the bucket (comma separated):",
-                default: "",
-            },
-            {
-                type: "confirm",
-                name: "bucketCompression",
-                message: "Do you want to enable compression for the bucket?",
-                default: false,
-            },
-            {
-                type: "list",
-                name: "bucketCompressionType",
-                message: "Select the compression type for the bucket:",
-                choices: Object.values(Compression),
-                default: Compression.None,
-                when: (answers) => answers.bucketCompression,
-            },
-            {
-                type: "confirm",
-                name: "bucketEncryption",
-                message: "Do you want to enable encryption for the bucket?",
-                default: false,
-            },
-            {
-                type: "confirm",
-                name: "bucketAntivirus",
-                message: "Do you want to enable antivirus for the bucket?",
-                default: false,
-            },
-            {
-                type: "input",
-                name: "bucketId",
-                message: "Enter the ID of the bucket (or empty for auto-generation):",
-            },
-        ]);
-        return await createBucket(storage, {
-            name: bucketName,
-            $permissions: [],
-            enabled: bucketEnabled,
-            fileSecurity: bucketFileSecurity,
-            maximumFileSize: bucketMaximumFileSize * 1024 * 1024,
-            allowedFileExtensions: bucketAllowedFileExtensions.length > 0
-                ? bucketAllowedFileExtensions?.split(",")
-                : [],
-            compression: bucketCompressionType,
-            encryption: bucketEncryption,
-            antivirus: bucketAntivirus,
-        }, bucketId.length > 0 ? bucketId : ulid());
-    }
-    getLocalCollections() {
-        const configCollections = this.controller.config?.collections || [];
-        // @ts-expect-error - appwrite invalid types
-        return configCollections.map((c) => ({
-            $id: c.$id || ulid(),
-            $createdAt: DateTime.now().toISO(),
-            $updatedAt: DateTime.now().toISO(),
-            name: c.name,
-            enabled: c.enabled || true,
-            documentSecurity: c.documentSecurity || false,
-            attributes: c.attributes || [],
-            indexes: c.indexes || [],
-            $permissions: PermissionToAppwritePermission(c.$permissions) || [],
-            databaseId: c.databaseId,
-            _isFromTablesDir: c._isFromTablesDir || false,
-            _sourceFolder: c._isFromTablesDir ? 'tables' : 'collections',
-        }));
-    }
-    getLocalDatabases() {
-        const configDatabases = this.controller.config?.databases || [];
-        return configDatabases.map((db) => ({
-            $id: db.$id || ulid(),
-            $createdAt: DateTime.now().toISO(),
-            $updatedAt: DateTime.now().toISO(),
-            name: db.name,
-            enabled: true,
-            type: "tablesdb",
-        }));
-    }
-    /**
-     * Extract session information from current controller for preservation
-     */
-    async extractSessionFromController() {
-        if (!this.controller?.config) {
-            return undefined;
-        }
-        const sessionInfo = await this.controller.getSessionInfo();
-        const config = this.controller.config;
-        if (!config.appwriteEndpoint || !config.appwriteProject) {
-            return undefined;
-        }
-        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 {
-            // Check for YAML config first
-            const yamlConfigPath = findYamlConfig(this.currentDir);
-            if (yamlConfigPath) {
-                this.isUsingTypeScriptConfig = false;
-                MessageFormatter.info("Using YAML configuration", { prefix: "Config" });
-                return;
-            }
-            // Then check for TypeScript config
-            const configPath = findAppwriteConfig(this.currentDir);
-            if (configPath) {
-                const tsConfigPath = join(configPath, 'appwriteConfig.ts');
-                if (fs.existsSync(tsConfigPath)) {
-                    this.isUsingTypeScriptConfig = true;
-                    MessageFormatter.info("TypeScript configuration detected", { prefix: "Config" });
-                    MessageFormatter.info("Consider migrating to YAML for better organization", { prefix: "Config" });
-                    return;
-                }
-            }
-            // No config found
-            this.isUsingTypeScriptConfig = false;
-            MessageFormatter.info("No configuration file found", { prefix: "Config" });
-        }
-        catch (error) {
-            // Silently handle detection errors and continue
-            this.isUsingTypeScriptConfig = false;
-        }
-    }
-    buildChoicesList() {
-        const allChoices = Object.values(CHOICES);
-        if (this.isUsingTypeScriptConfig) {
-            // Place migration option at the top when TS config is detected
-            return [
-                CHOICES.MIGRATE_CONFIG,
-                ...allChoices.filter(choice => choice !== CHOICES.MIGRATE_CONFIG)
-            ];
-        }
-        else {
-            // Hide migration option when using YAML config
-            return allChoices.filter(choice => choice !== CHOICES.MIGRATE_CONFIG);
-        }
-    }
-}