appwrite-utils-cli 1.9.6 → 1.11.0

package/dist/cli/commands/functionCommands.js

@@ -1,330 +0,0 @@
-import inquirer from "inquirer";
-import { join } from "node:path";
-import fs from "node:fs";
-import os from "node:os";
-import { ulid } from "ulidx";
-import chalk from "chalk";
-import { Query } from "node-appwrite";
-import { MessageFormatter } from "../../shared/messageFormatter.js";
-import { createFunctionTemplate, deleteFunction, downloadLatestFunctionDeployment, listFunctions, listSpecifications, } from "../../functions/methods.js";
-import { deployLocalFunction } from "../../functions/deployments.js";
-import { discoverFnConfigs, mergeDiscoveredFunctions } from "../../functions/fnConfigDiscovery.js";
-import { addFunctionToYamlConfig, findYamlConfig } from "../../config/yamlConfig.js";
-import { RuntimeSchema } from "appwrite-utils";
-export const functionCommands = {
-    async createFunction(cli) {
-        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: "TypeScript with Hono Web Framework", value: "hono-typescript" },
-                    { 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 = cli.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(cli.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 (!cli.controller.config.functions) {
-            cli.controller.config.functions = [];
-        }
-        cli.controller.config.functions.push(functionConfig);
-        // If using YAML config, also add to YAML file
-        const yamlConfigPath = findYamlConfig(cli.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 deployFunction(cli) {
-        await cli.initControllerIfNeeded();
-        if (!cli.controller?.config) {
-            MessageFormatter.error("Failed to initialize controller or load config", undefined, { prefix: "Functions" });
-            return;
-        }
-        // Discover per-function .fnconfig.yaml definitions and merge with central list for selection
-        // No global prompt; we'll handle conflicts per-function if both exist.
-        let discovered = [];
-        let central = cli.controller.config.functions || [];
-        try {
-            discovered = discoverFnConfigs(cli.currentDir);
-            const merged = mergeDiscoveredFunctions(central, discovered);
-            cli.controller.config.functions = merged;
-        }
-        catch { }
-        const functions = await cli.selectFunctions("Select function(s) to deploy:", true, true);
-        if (!functions?.length) {
-            MessageFormatter.error("No function selected", undefined, { prefix: "Functions" });
-            return;
-        }
-        for (const functionConfig of functions) {
-            if (!functionConfig) {
-                MessageFormatter.error("Invalid function configuration", undefined, { prefix: "Functions" });
-                return;
-            }
-            // Resolve effective config for this function (prefer per-function choice if both sources exist)
-            const byIdOrName = (arr) => arr.find((f) => f?.$id === functionConfig.$id || f?.name === functionConfig.name);
-            const centralDef = byIdOrName(central);
-            const discoveredDef = byIdOrName(discovered);
-            let effectiveConfig = functionConfig;
-            if (centralDef && discoveredDef) {
-                try {
-                    const answer = await inquirer.prompt([
-                        {
-                            type: 'list',
-                            name: 'cfgChoice',
-                            message: `Multiple configs found for '${functionConfig.name}'. Which to use?`,
-                            choices: [
-                                { name: 'config.yaml (central)', value: 'central' },
-                                { name: '.fnconfig.yaml (local file)', value: 'fnconfig' },
-                                { name: 'Merge (.fnconfig overrides central)', value: 'merge' },
-                            ],
-                            default: 'fnconfig'
-                        }
-                    ]);
-                    if (answer.cfgChoice === 'central')
-                        effectiveConfig = centralDef;
-                    else if (answer.cfgChoice === 'fnconfig')
-                        effectiveConfig = discoveredDef;
-                    else
-                        effectiveConfig = { ...centralDef, ...discoveredDef };
-                }
-                catch { }
-            }
-            // Ensure functions array exists
-            if (!cli.controller.config.functions) {
-                cli.controller.config.functions = [];
-            }
-            const functionNameLower = effectiveConfig.name
-                .toLowerCase()
-                .replace(/\s+/g, "-");
-            // Debug logging
-            MessageFormatter.info(`🔍 Function deployment debug:`, { prefix: "Functions" });
-            MessageFormatter.info(`  Function name: ${effectiveConfig.name}`, { prefix: "Functions" });
-            MessageFormatter.info(`  Function ID: ${effectiveConfig.$id}`, { prefix: "Functions" });
-            MessageFormatter.info(`  Config dirPath: ${effectiveConfig.dirPath || 'undefined'}`, { prefix: "Functions" });
-            if (effectiveConfig.dirPath) {
-                const expandedPath = effectiveConfig.dirPath.startsWith('~/')
-                    ? effectiveConfig.dirPath.replace('~', os.homedir())
-                    : effectiveConfig.dirPath;
-                MessageFormatter.info(`  Expanded dirPath: ${expandedPath}`, { prefix: "Functions" });
-            }
-            MessageFormatter.info(`  Appwrite folder: ${cli.controller.getAppwriteFolderPath()}`, { prefix: "Functions" });
-            MessageFormatter.info(`  Current working dir: ${process.cwd()}`, { prefix: "Functions" });
-            // Resolve config dirPath relative to central YAML if it's relative
-            const yamlConfigPath = findYamlConfig(cli.currentDir);
-            const yamlBaseDir = yamlConfigPath ? require('node:path').dirname(yamlConfigPath) : process.cwd();
-            const expandTildePath = (p) => (p?.startsWith('~/') ? p.replace('~', os.homedir()) : p);
-            // Check locations in priority order:
-            const priorityLocations = [
-                // 1. Config dirPath if specified (with tilde expansion)
-                effectiveConfig.dirPath
-                    ? (require('node:path').isAbsolute(expandTildePath(effectiveConfig.dirPath))
-                        ? expandTildePath(effectiveConfig.dirPath)
-                        : require('node:path').resolve(yamlBaseDir, expandTildePath(effectiveConfig.dirPath)))
-                    : undefined,
-                // 2. Appwrite config folder/functions/name
-                join(cli.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);
-            MessageFormatter.info(`🔍 Priority locations to check:`, { prefix: "Functions" });
-            priorityLocations.forEach((loc, i) => {
-                MessageFormatter.info(`  ${i + 1}. ${loc}`, { prefix: "Functions" });
-            });
-            let functionPath = null;
-            // Check each priority location
-            for (const location of priorityLocations) {
-                MessageFormatter.info(`  Checking: ${location} - ${fs.existsSync(location) ? 'EXISTS' : 'NOT FOUND'}`, { prefix: "Functions" });
-                if (fs.existsSync(location)) {
-                    MessageFormatter.success(`✅ Found function at: ${location}`, { prefix: "Functions" });
-                    functionPath = location;
-                    break;
-                }
-            }
-            // If not found in priority locations, do a broader search
-            if (!functionPath) {
-                MessageFormatter.info(`Function not found in primary locations, searching subdirectories...`, { prefix: "Functions" });
-                // Search in both appwrite config directory and current working directory
-                functionPath = await cli.findFunctionInSubdirectories([cli.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 {
-                        MessageFormatter.progress("Downloading latest deployment...", { prefix: "Functions" });
-                        const { path: downloadedPath, function: remoteFunction } = await downloadLatestFunctionDeployment(cli.controller.appwriteServer, effectiveConfig.$id, join(cli.controller.getAppwriteFolderPath(), "functions"));
-                        MessageFormatter.success(`✨ Function downloaded to ${downloadedPath}`, { prefix: "Functions" });
-                        functionPath = downloadedPath;
-                        effectiveConfig.dirPath = downloadedPath;
-                        const existingIndex = cli.controller.config.functions.findIndex((f) => f?.$id === remoteFunction.$id);
-                        if (existingIndex >= 0) {
-                            cli.controller.config.functions[existingIndex].dirPath =
-                                downloadedPath;
-                        }
-                        await cli.reloadConfigWithSessionPreservation();
-                    }
-                    catch (error) {
-                        MessageFormatter.error("Failed to download function deployment", error instanceof Error ? error : new Error(String(error)), { prefix: "Functions" });
-                        return;
-                    }
-                }
-                else {
-                    MessageFormatter.error(`Function ${effectiveConfig.name} not found locally. Cannot deploy.`, undefined, { prefix: "Functions" });
-                    return;
-                }
-            }
-            if (!cli.controller.appwriteServer) {
-                MessageFormatter.error("Appwrite server not initialized", undefined, { prefix: "Functions" });
-                return;
-            }
-            try {
-                await deployLocalFunction(cli.controller.appwriteServer, effectiveConfig.name, {
-                    ...effectiveConfig,
-                    dirPath: functionPath,
-                }, functionPath);
-                MessageFormatter.success("Function deployed successfully!", { prefix: "Functions" });
-            }
-            catch (error) {
-                MessageFormatter.error("Failed to deploy function", error instanceof Error ? error : new Error(String(error)), { prefix: "Functions" });
-            }
-        }
-    },
-    async deleteFunction(cli) {
-        const functions = await cli.selectFunctions("Select functions to delete:", true, false);
-        if (!functions.length) {
-            MessageFormatter.error("No functions selected", undefined, { prefix: "Functions" });
-            return;
-        }
-        for (const func of functions) {
-            try {
-                await deleteFunction(cli.controller.appwriteServer, func.$id);
-                MessageFormatter.success(`✨ Function ${func.name} deleted successfully!`, { prefix: "Functions" });
-            }
-            catch (error) {
-                MessageFormatter.error(`Failed to delete function ${func.name}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Functions" });
-            }
-        }
-    },
-    async updateFunctionSpec(cli) {
-        const remoteFunctions = await listFunctions(cli.controller.appwriteServer, [Query.limit(1000)]);
-        const localFunctions = cli.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(cli.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 cli.controller.updateFunctionSpecifications(functionId, specification);
-                MessageFormatter.success(`Successfully updated function specification to ${specification}`, { prefix: "Functions" });
-            }
-        }
-        catch (error) {
-            MessageFormatter.error("Error updating function specification", error instanceof Error ? error : new Error(String(error)), { prefix: "Functions" });
-        }
-    }
-};

package/dist/cli/commands/schemaCommands.d.ts

@@ -1,7 +0,0 @@
-import type { InteractiveCLI } from "../../interactiveCLI.js";
-export declare const schemaCommands: {
-    generateSchemas(cli: InteractiveCLI): Promise<void>;
-    generateConstants(cli: InteractiveCLI): Promise<void>;
-    importData(cli: InteractiveCLI): Promise<void>;
-    setupDirsFiles(cli: InteractiveCLI, withExampleData?: boolean): Promise<void>;
-};

package/dist/cli/commands/schemaCommands.js

@@ -1,169 +0,0 @@
-import inquirer from "inquirer";
-import path from "path";
-import chalk from "chalk";
-import { MessageFormatter } from "../../shared/messageFormatter.js";
-import { SchemaGenerator } from "../../shared/schemaGenerator.js";
-import { setupDirsFiles } from "../../utils/setupFiles.js";
-import { fetchAllDatabases } from "../../databases/methods.js";
-export const schemaCommands = {
-    async generateSchemas(cli) {
-        MessageFormatter.progress("Generating schemas...", { prefix: "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: "Python (Pydantic) models", value: "pydantic" },
-                    { name: "TypeScript + JSON", value: "both" },
-                    { name: "All (Zod, JSON, Pydantic)", value: "all" },
-                ],
-                default: "all",
-            },
-        ]);
-        // Get the config folder path (where the config file is located)
-        const configFolderPath = cli.controller.getAppwriteFolderPath();
-        if (!configFolderPath) {
-            MessageFormatter.error("Failed to get config folder path", undefined, { prefix: "Schemas" });
-            return;
-        }
-        // Prompt for schema output directory (optional override)
-        const defaultSchemaOut = path.join(configFolderPath, cli.controller.config?.schemaConfig?.outputDirectory || 'schemas');
-        const { schemaOutDir } = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'schemaOutDir',
-                message: 'Output directory for schemas:',
-                default: defaultSchemaOut,
-                validate: (input) => input && input.trim().length > 0 ? true : 'Please provide an output directory',
-            }
-        ]);
-        // Create SchemaGenerator with the correct base path and generate schemas
-        const schemaGenerator = new SchemaGenerator(cli.controller.config, configFolderPath);
-        const outDirRel = path.isAbsolute(schemaOutDir) ? schemaOutDir : path.relative(configFolderPath, schemaOutDir);
-        await schemaGenerator.generateSchemas({ format: schemaType, verbose: true, outputDir: outDirRel });
-        MessageFormatter.success("Schema generation completed", { prefix: "Schemas" });
-    },
-    async generateConstants(cli) {
-        MessageFormatter.progress("Generating cross-language constants...", { prefix: "Constants" });
-        if (!cli.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;
-                },
-            },
-        ]);
-        // Prompt for which constants to include
-        const { includeWhat } = await inquirer.prompt([
-            {
-                type: 'checkbox',
-                name: 'includeWhat',
-                message: 'Select which constants to generate:',
-                choices: [
-                    { name: 'Databases', value: 'databases', checked: true },
-                    { name: 'Collections/Tables', value: 'collections', checked: true },
-                    { name: 'Buckets', value: 'buckets', checked: true },
-                    { name: 'Functions', value: 'functions', checked: true },
-                ],
-                validate: (input) => input.length > 0 ? true : 'Select at least one category',
-            }
-        ]);
-        // Determine default output directory based on config location
-        const configPath = cli.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(cli.controller.config);
-            const include = {
-                databases: includeWhat.includes('databases'),
-                collections: includeWhat.includes('collections'),
-                buckets: includeWhat.includes('buckets'),
-                functions: includeWhat.includes('functions'),
-            };
-            MessageFormatter.info(`Generating constants for: ${languages.join(", ")}`, { prefix: "Constants" });
-            await generator.generateFiles(languages, outputDir, include);
-            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(cli) {
-        MessageFormatter.progress("Importing data...", { prefix: "Import" });
-        const { doBackup } = await inquirer.prompt([
-            {
-                type: "confirm",
-                name: "doBackup",
-                message: "Do you want to perform a backup before importing?",
-                default: true,
-            },
-        ]);
-        const databases = await cli.selectDatabases(await fetchAllDatabases(cli.controller.database), "Select databases to import data into:", true);
-        const collections = await cli.selectCollectionsAndTables(databases[0], cli.controller.database, "Select collections/tables 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 cli.controller.importData(options);
-            MessageFormatter.success("Data import completed successfully", { prefix: "Import" });
-        }
-        catch (error) {
-            MessageFormatter.error("Error importing data", error instanceof Error ? error : new Error(String(error)), { prefix: "Import" });
-        }
-    },
-    async setupDirsFiles(cli, withExampleData = false) {
-        await setupDirsFiles(withExampleData, cli.currentDir);
-    }
-};

package/dist/cli/commands/storageCommands.d.ts

@@ -1,5 +0,0 @@
-import type { InteractiveCLI } from "../../interactiveCLI.js";
-export declare const storageCommands: {
-    createBucket(cli: InteractiveCLI): Promise<void>;
-    deleteBuckets(cli: InteractiveCLI): Promise<void>;
-};

package/dist/cli/commands/storageCommands.js

@@ -1,143 +0,0 @@
-import inquirer from "inquirer";
-import chalk from "chalk";
-import { Storage, Permission, Role, Compression } from "node-appwrite";
-import { MessageFormatter } from "../../shared/messageFormatter.js";
-import { listBuckets, createBucket as createBucketApi, deleteBucket as deleteBucketApi } from "../../storage/methods.js";
-import { writeYamlConfig } from "../../config/yamlConfig.js";
-import { ConfigManager } from "../../config/ConfigManager.js";
-export const storageCommands = {
-    async createBucket(cli) {
-        const storage = cli.controller.storage;
-        if (!storage) {
-            MessageFormatter.error("Storage client not initialized", undefined, { prefix: "Buckets" });
-            return;
-        }
-        const answers = await inquirer.prompt([
-            { type: 'input', name: 'name', message: 'Bucket name:', validate: (v) => v?.trim()?.length > 0 || 'Required' },
-            { type: 'input', name: 'id', message: 'Bucket ID (optional):' },
-            { type: 'confirm', name: 'publicRead', message: 'Public read access?', default: false },
-            { type: 'confirm', name: 'fileSecurity', message: 'Enable file-level security?', default: false },
-            { type: 'confirm', name: 'enabled', message: 'Enable bucket?', default: true },
-            { type: 'number', name: 'maximumFileSize', message: 'Max file size (bytes, optional):', default: undefined },
-            { type: 'input', name: 'allowedFileExtensions', message: 'Allowed extensions (comma separated, optional):', default: '' },
-            { type: 'list', name: 'compression', message: 'Compression:', choices: ['none', 'gzip', 'zstd'], default: 'none' },
-            { type: 'confirm', name: 'encryption', message: 'Enable encryption?', default: false },
-            { type: 'confirm', name: 'antivirus', message: 'Enable antivirus?', default: false },
-        ]);
-        const permissions = [];
-        if (answers.publicRead)
-            permissions.push(Permission.read(Role.any()));
-        const bucketInput = {
-            name: answers.name,
-            $permissions: permissions,
-            fileSecurity: !!answers.fileSecurity,
-            enabled: !!answers.enabled,
-            maximumFileSize: answers.maximumFileSize || undefined,
-            allowedFileExtensions: String(answers.allowedFileExtensions || '')
-                .split(',')
-                .map((s) => s.trim())
-                .filter(Boolean),
-            compression: answers.compression,
-            encryption: !!answers.encryption,
-            antivirus: !!answers.antivirus,
-        };
-        try {
-            const created = await createBucketApi(storage, bucketInput, answers.id || undefined);
-            MessageFormatter.success(`Bucket '${answers.name}' created`, { prefix: 'Buckets' });
-            // Update in-memory config and persist to YAML as a global bucket entry
-            const controller = cli.controller;
-            controller.config.buckets = controller.config.buckets || [];
-            controller.config.buckets.push({
-                $id: created.$id || answers.id || bucketInput.name,
-                name: bucketInput.name,
-                permissions: [],
-                fileSecurity: bucketInput.fileSecurity,
-                enabled: bucketInput.enabled,
-                maximumFileSize: bucketInput.maximumFileSize,
-                allowedFileExtensions: bucketInput.allowedFileExtensions,
-                compression: bucketInput.compression,
-                encryption: bucketInput.encryption,
-                antivirus: bucketInput.antivirus,
-            });
-            const cfgMgr = ConfigManager.getInstance();
-            const cfgPath = cfgMgr.getConfigPath();
-            if (cfgPath && /\.ya?ml$/i.test(cfgPath)) {
-                await writeYamlConfig(cfgPath, controller.config);
-                MessageFormatter.info(`Added bucket to config.yaml`, { prefix: 'Buckets' });
-            }
-            else {
-                MessageFormatter.warning(`Config is not YAML; updated in-memory only. Please update your TypeScript config manually.`, { prefix: 'Buckets' });
-            }
-        }
-        catch (e) {
-            MessageFormatter.error('Failed to create bucket', e instanceof Error ? e : new Error(String(e)), { prefix: 'Buckets' });
-        }
-    },
-    async deleteBuckets(cli) {
-        const storage = cli.controller.storage;
-        if (!storage) {
-            MessageFormatter.error("Storage client not initialized", undefined, { prefix: "Buckets" });
-            return;
-        }
-        try {
-            const res = await listBuckets(storage);
-            const buckets = res.buckets || [];
-            if (buckets.length === 0) {
-                MessageFormatter.info('No buckets found', { prefix: 'Buckets' });
-                return;
-            }
-            const { toDelete } = await inquirer.prompt([
-                {
-                    type: 'checkbox',
-                    name: 'toDelete',
-                    message: chalk.red('Select buckets to delete:'),
-                    choices: buckets.map((b) => ({ name: `${b.name} (${b.$id})`, value: b.$id })),
-                    pageSize: 10,
-                }
-            ]);
-            if (!toDelete || toDelete.length === 0) {
-                MessageFormatter.info('No buckets selected', { prefix: 'Buckets' });
-                return;
-            }
-            const { confirm } = await inquirer.prompt([
-                { type: 'confirm', name: 'confirm', message: `Delete ${toDelete.length} bucket(s)?`, default: false }
-            ]);
-            if (!confirm)
-                return;
-            const controller = cli.controller;
-            for (const id of toDelete) {
-                try {
-                    await deleteBucketApi(storage, id);
-                    MessageFormatter.success(`Deleted bucket ${id}`, { prefix: 'Buckets' });
-                    // Remove from in-memory config (global buckets)
-                    if (Array.isArray(controller.config.buckets)) {
-                        controller.config.buckets = controller.config.buckets.filter((b) => b.$id !== id);
-                    }
-                    // Clear database-linked bucket references if matching
-                    if (Array.isArray(controller.config.databases)) {
-                        controller.config.databases = controller.config.databases.map((db) => ({
-                            ...db,
-                            bucket: db.bucket && db.bucket.$id === id ? undefined : db.bucket,
-                        }));
-                    }
-                }
-                catch (e) {
-                    MessageFormatter.error(`Failed to delete bucket ${id}`, e instanceof Error ? e : new Error(String(e)), { prefix: 'Buckets' });
-                }
-            }
-            // Persist YAML changes
-            const cfgMgr = ConfigManager.getInstance();
-            const cfgPath = cfgMgr.getConfigPath();
-            if (cfgPath && /\.ya?ml$/i.test(cfgPath)) {
-                await writeYamlConfig(cfgPath, controller.config);
-                MessageFormatter.info(`Updated config.yaml after deletion`, { prefix: 'Buckets' });
-            }
-            else {
-                MessageFormatter.warning(`Config is not YAML; updated in-memory only. Please update your TypeScript config manually.`, { prefix: 'Buckets' });
-            }
-        }
-        catch (e) {
-            MessageFormatter.error('Failed to list buckets', e instanceof Error ? e : new Error(String(e)), { prefix: 'Buckets' });
-        }
-    }
-};

package/dist/cli/commands/transferCommands.d.ts

@@ -1,5 +0,0 @@
-import type { InteractiveCLI } from "../../interactiveCLI.js";
-export declare const transferCommands: {
-    transferData(cli: InteractiveCLI): Promise<void>;
-    comprehensiveTransfer(cli: InteractiveCLI): Promise<void>;
-};