appwrite-utils-cli 1.8.2 → 1.8.5

package/dist/storage/methods.js

@@ -44,8 +44,54 @@ export const ensureDatabaseConfigBucketsExist = async (storage, config, database
         const database = config.databases?.find((d) => d.$id === db.$id);
         if (database?.bucket) {
             try {
-                await storage.getBucket(database.bucket.$id);
-                console.log(`Bucket ${database.bucket.$id} already exists.`);
+                const existing = await storage.getBucket(database.bucket.$id);
+                // Compare and update if needed
+                const desired = database.bucket;
+                // Build desired permissions via Permission helper
+                const permissions = [];
+                if (desired.permissions && desired.permissions.length > 0) {
+                    for (const p of desired.permissions) {
+                        switch (p.permission) {
+                            case 'read':
+                                permissions.push(Permission.read(p.target));
+                                break;
+                            case 'create':
+                                permissions.push(Permission.create(p.target));
+                                break;
+                            case 'update':
+                                permissions.push(Permission.update(p.target));
+                                break;
+                            case 'delete':
+                                permissions.push(Permission.delete(p.target));
+                                break;
+                            case 'write':
+                                permissions.push(Permission.write(p.target));
+                                break;
+                            default: break;
+                        }
+                    }
+                }
+                const diff = (existing.name !== desired.name ||
+                    JSON.stringify(existing.$permissions || []) !== JSON.stringify(permissions) ||
+                    !!existing.fileSecurity !== !!desired.fileSecurity ||
+                    !!existing.enabled !== !!desired.enabled ||
+                    (existing.maximumFileSize ?? undefined) !== (desired.maximumFileSize ?? undefined) ||
+                    JSON.stringify(existing.allowedFileExtensions || []) !== JSON.stringify(desired.allowedFileExtensions || []) ||
+                    String(existing.compression || 'none') !== String(desired.compression || 'none') ||
+                    !!existing.encryption !== !!desired.encryption ||
+                    !!existing.antivirus !== !!desired.antivirus);
+                if (diff) {
+                    try {
+                        await storage.updateBucket(desired.$id, desired.name, permissions, desired.fileSecurity, desired.enabled, desired.maximumFileSize, desired.allowedFileExtensions, desired.compression, desired.encryption, desired.antivirus);
+                        MessageFormatter.info(`Updated bucket ${desired.$id} to match config`, { prefix: 'Buckets' });
+                    }
+                    catch (updateErr) {
+                        MessageFormatter.warning(`Failed to update bucket ${desired.$id}: ${updateErr instanceof Error ? updateErr.message : String(updateErr)}`, { prefix: 'Buckets' });
+                    }
+                }
+                else {
+                    MessageFormatter.debug(`Bucket ${desired.$id} up-to-date`, undefined, { prefix: 'Buckets' });
+                }
             }
             catch (e) {
                 const permissions = [];
@@ -76,13 +122,10 @@ export const ensureDatabaseConfigBucketsExist = async (storage, config, database
                 }
                 try {
                     await storage.createBucket(database.bucket.$id, database.bucket.name, permissions, database.bucket.fileSecurity, database.bucket.enabled, database.bucket.maximumFileSize, database.bucket.allowedFileExtensions, database.bucket.compression, database.bucket.encryption, database.bucket.antivirus);
-                    console.log(`Bucket ${database.bucket.$id} created successfully.`);
+                    MessageFormatter.success(`Bucket ${database.bucket.$id} created`, { prefix: 'Buckets' });
                 }
                 catch (createError) {
-                    // console.error(
-                    //   `Failed to create bucket ${database.bucket.$id}:`,
-                    //   createError
-                    // );
+                    MessageFormatter.error(`Failed to create bucket ${database.bucket.$id}`, createError instanceof Error ? createError : new Error(String(createError)), { prefix: 'Buckets' });
                 }
             }
         }

package/dist/utils/configDiscovery.js

@@ -152,7 +152,7 @@ const YamlTableSchema = z.object({
         size: z.number().optional(),
         required: z.boolean().default(false),
         array: z.boolean().optional(),
-        encrypted: z.boolean().optional(), // Tables support encrypted property
+        encrypt: z.boolean().optional(), // Tables support encrypt property
         default: z.any().optional(),
         min: z.number().optional(),
         max: z.number().optional(),
@@ -163,7 +163,6 @@ const YamlTableSchema = z.object({
         twoWayKey: z.string().optional(),
         onDelete: z.string().optional(),
         side: z.string().optional(),
-        encrypt: z.boolean().optional(),
         format: z.string().optional()
     })).optional().default([]),
     indexes: z.array(z.object({
@@ -266,7 +265,7 @@ export const loadYamlTable = (filePath) => {
                 twoWayKey: col.twoWayKey,
                 onDelete: col.onDelete,
                 side: col.side,
-                encrypted: col.encrypted || col.encrypt, // Support both encrypted and encrypt
+                encrypt: col.encrypt,
                 format: col.format
             })),
             indexes: parsedTable.indexes.map(idx => ({

package/dist/utils/constantsGenerator.d.ts

@@ -1,5 +1,11 @@
 import { type AppwriteConfig } from "appwrite-utils";
 export type SupportedLanguage = "typescript" | "javascript" | "python" | "php" | "dart" | "json" | "env";
+interface Constants {
+    databases: Record<string, string>;
+    collections: Record<string, string>;
+    buckets: Record<string, string>;
+    functions: Record<string, string>;
+}
 export declare class ConstantsGenerator {
     private config;
     private constants;
@@ -8,12 +14,18 @@ export declare class ConstantsGenerator {
     private toConstantName;
     private toCamelCase;
     private toSnakeCase;
-    generateTypeScript(): string;
-    generateJavaScript(): string;
-    generatePython(): string;
-    generatePHP(): string;
-    generateDart(): string;
-    generateJSON(): string;
-    generateEnv(): string;
-    generateFiles(languages: SupportedLanguage[], outputDir: string): Promise<void>;
+    generateTypeScript(constantsOverride?: Constants): string;
+    generateJavaScript(constantsOverride?: Constants): string;
+    generatePython(constantsOverride?: Constants): string;
+    generatePHP(constantsOverride?: Constants): string;
+    generateDart(constantsOverride?: Constants): string;
+    generateJSON(constantsOverride?: Constants): string;
+    generateEnv(constantsOverride?: Constants): string;
+    generateFiles(languages: SupportedLanguage[], outputDir: string, include?: {
+        databases?: boolean;
+        collections?: boolean;
+        buckets?: boolean;
+        functions?: boolean;
+    }): Promise<void>;
 }
+export {};

package/dist/utils/constantsGenerator.js

@@ -61,8 +61,8 @@ export class ConstantsGenerator {
     toSnakeCase(name) {
         return name.toLowerCase();
     }
-    generateTypeScript() {
-        const { databases, collections, buckets, functions } = this.constants;
+    generateTypeScript(constantsOverride) {
+        const { databases, collections, buckets, functions } = constantsOverride || this.constants;
         return `// Auto-generated Appwrite constants
 // Generated on ${new Date().toISOString()}
 
@@ -95,8 +95,8 @@ export const ALL_BUCKET_IDS = Object.values(BUCKET_IDS);
 export const ALL_FUNCTION_IDS = Object.values(FUNCTION_IDS);
 `;
     }
-    generateJavaScript() {
-        const { databases, collections, buckets, functions } = this.constants;
+    generateJavaScript(constantsOverride) {
+        const { databases, collections, buckets, functions } = constantsOverride || this.constants;
         return `// Auto-generated Appwrite constants
 // Generated on ${new Date().toISOString()}
 
@@ -123,8 +123,8 @@ export const ALL_BUCKET_IDS = Object.values(BUCKET_IDS);
 export const ALL_FUNCTION_IDS = Object.values(FUNCTION_IDS);
 `;
     }
-    generatePython() {
-        const { databases, collections, buckets, functions } = this.constants;
+    generatePython(constantsOverride) {
+        const { databases, collections, buckets, functions } = constantsOverride || this.constants;
         return `# Auto-generated Appwrite constants
 # Generated on ${new Date().toISOString()}
 
@@ -162,8 +162,8 @@ ${Object.entries(functions).map(([key, value]) => `    "${this.toSnakeCase(key)}
 }
 `;
     }
-    generatePHP() {
-        const { databases, collections, buckets, functions } = this.constants;
+    generatePHP(constantsOverride) {
+        const { databases, collections, buckets, functions } = constantsOverride || this.constants;
         return `<?php
 // Auto-generated Appwrite constants
 // Generated on ${new Date().toISOString()}
@@ -216,8 +216,8 @@ ${Object.entries(functions).map(([key, value]) => `        '${key}' => '${value}
 }
 `;
     }
-    generateDart() {
-        const { databases, collections, buckets, functions } = this.constants;
+    generateDart(constantsOverride) {
+        const { databases, collections, buckets, functions } = constantsOverride || this.constants;
         return `// Auto-generated Appwrite constants
 // Generated on ${new Date().toISOString()}
 
@@ -250,20 +250,21 @@ ${Object.entries(functions).map(([key, value]) => `  static String get ${this.to
 }
 `;
     }
-    generateJSON() {
+    generateJSON(constantsOverride) {
+        const c = constantsOverride || this.constants;
         return JSON.stringify({
             meta: {
                 generated: new Date().toISOString(),
                 generator: "appwrite-utils-cli"
             },
-            databases: this.constants.databases,
-            collections: this.constants.collections,
-            buckets: this.constants.buckets,
-            functions: this.constants.functions
+            databases: c.databases,
+            collections: c.collections,
+            buckets: c.buckets,
+            functions: c.functions
         }, null, 2);
     }
-    generateEnv() {
-        const { databases, collections, buckets, functions } = this.constants;
+    generateEnv(constantsOverride) {
+        const { databases, collections, buckets, functions } = constantsOverride || this.constants;
         const lines = [
             "# Auto-generated Appwrite constants",
             `# Generated on ${new Date().toISOString()}`,
@@ -282,16 +283,27 @@ ${Object.entries(functions).map(([key, value]) => `  static String get ${this.to
         ];
         return lines.join('\n');
     }
-    async generateFiles(languages, outputDir) {
+    async generateFiles(languages, outputDir, include) {
         await fs.mkdir(outputDir, { recursive: true });
+        const filterConstants = () => {
+            if (!include)
+                return this.constants;
+            return {
+                databases: include.databases === false ? {} : this.constants.databases,
+                collections: include.collections === false ? {} : this.constants.collections,
+                buckets: include.buckets === false ? {} : this.constants.buckets,
+                functions: include.functions === false ? {} : this.constants.functions,
+            };
+        };
+        const subset = filterConstants();
         const generators = {
-            typescript: () => ({ content: this.generateTypeScript(), filename: "appwrite-constants.ts" }),
-            javascript: () => ({ content: this.generateJavaScript(), filename: "appwrite-constants.js" }),
-            python: () => ({ content: this.generatePython(), filename: "appwrite_constants.py" }),
-            php: () => ({ content: this.generatePHP(), filename: "AppwriteConstants.php" }),
-            dart: () => ({ content: this.generateDart(), filename: "appwrite_constants.dart" }),
-            json: () => ({ content: this.generateJSON(), filename: "appwrite-constants.json" }),
-            env: () => ({ content: this.generateEnv(), filename: ".env.appwrite" })
+            typescript: () => ({ content: this.generateTypeScript(subset), filename: "appwrite-constants.ts" }),
+            javascript: () => ({ content: this.generateJavaScript(subset), filename: "appwrite-constants.js" }),
+            python: () => ({ content: this.generatePython(subset), filename: "appwrite_constants.py" }),
+            php: () => ({ content: this.generatePHP(subset), filename: "AppwriteConstants.php" }),
+            dart: () => ({ content: this.generateDart(subset), filename: "appwrite_constants.dart" }),
+            json: () => ({ content: this.generateJSON(subset), filename: "appwrite-constants.json" }),
+            env: () => ({ content: this.generateEnv(subset), filename: ".env.appwrite" })
         };
         for (const language of languages) {
             const generator = generators[language];

package/dist/utils/projectConfig.js

@@ -134,7 +134,7 @@ export function getCollectionsFromProject(projectConfig) {
                 array: col.array,
                 size: col.size,
                 default: col.default,
-                encrypted: col.encrypt,
+                encrypt: col.encrypt,
                 unique: col.unique,
             })),
             indexes: table.indexes || [],

package/dist/utils/yamlConverter.d.ts

@@ -15,7 +15,7 @@ export interface YamlCollectionData {
         size?: number;
         required?: boolean;
         array?: boolean;
-        encrypted?: boolean;
+        encrypt?: boolean;
         default?: any;
         min?: number;
         max?: number;
@@ -33,7 +33,7 @@ export interface YamlCollectionData {
         size?: number;
         required?: boolean;
         array?: boolean;
-        encrypted?: boolean;
+        encrypt?: boolean;
         default?: any;
         min?: number;
         max?: number;

package/dist/utils/yamlConverter.js

@@ -125,9 +125,9 @@ export function collectionToYaml(collection, config = {
                 yamlAttr.required = attr.required;
             if (attr.array !== undefined)
                 yamlAttr.array = attr.array;
-            // Always include encrypted field for string attributes (default to false)
+            // Always include encrypt field for string attributes (default to false)
             if (attr.type === 'string') {
-                yamlAttr.encrypted = ('encrypted' in attr && attr.encrypted === true) ? true : false;
+                yamlAttr.encrypt = ('encrypt' in attr && attr.encrypt === true) ? true : false;
             }
             if ('xdefault' in attr && attr.xdefault !== undefined)
                 yamlAttr.default = attr.xdefault;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "appwrite-utils-cli",
   "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
-  "version": "1.8.2",
+  "version": "1.8.5",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/adapters/TablesDBAdapter.ts

@@ -315,7 +315,7 @@ export class TablesDBAdapter extends BaseAdapter {
       const type = (params.type || "").toLowerCase();
       const required = params.required ?? false;
       const array = params.array ?? false;
-      const encrypt = params.encrypt ?? (params as any).encrypted ?? false;
+      const encrypt = params.encrypt ?? false;
       const normalizedDefault =
         params.default === null || params.default === undefined
           ? undefined

package/src/cli/commands/functionCommands.ts

@@ -138,11 +138,36 @@ export const functionCommands = {
       return;
     }
 
-    // Discover local .fnconfig.yaml functions and merge into controller config
+    // Offer choice of function config sources: central YAML, .fnconfig.yaml, or both
+    let sourceChoice: 'central' | 'fnconfig' | 'both' = 'both';
+    try {
+      const answer = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'source',
+          message: 'Select function config source:',
+          choices: [
+            { name: 'config.yaml functions (central)', value: 'central' },
+            { name: '.fnconfig.yaml (discovered per-function)', value: 'fnconfig' },
+            { name: 'Both (merge; .fnconfig overrides)', value: 'both' },
+          ],
+          default: 'both'
+        }
+      ]);
+      sourceChoice = answer.source;
+    } catch {}
+
     try {
       const discovered = discoverFnConfigs((cli as any).currentDir);
-      const merged = mergeDiscoveredFunctions((cli as any).controller!.config!.functions || [], discovered);
-      (cli as any).controller!.config!.functions = merged as any;
+      const central = (cli as any).controller!.config!.functions || [];
+      if (sourceChoice === 'central') {
+        (cli as any).controller!.config!.functions = central as any;
+      } else if (sourceChoice === 'fnconfig') {
+        (cli as any).controller!.config!.functions = discovered as any;
+      } else {
+        const merged = mergeDiscoveredFunctions(central, discovered);
+        (cli as any).controller!.config!.functions = merged as any;
+      }
     } catch {}
 
     const functions = await (cli as any).selectFunctions(

package/src/cli/commands/schemaCommands.ts

@@ -12,19 +12,21 @@ export const schemaCommands = {
     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: "Both TypeScript and JSON schemas", value: "both" },
-        ],
-        default: "both",
-      },
-    ]);
+    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 as any).controller!.getAppwriteFolderPath();
@@ -33,14 +35,27 @@ export const schemaCommands = {
       return;
     }
 
-    // Create SchemaGenerator with the correct base path and generate schemas
-    const schemaGenerator = new SchemaGenerator((cli as any).controller!.config!, configFolderPath);
-    schemaGenerator.generateSchemas({ format: schemaType, verbose: true });
+    // Prompt for schema output directory (optional override)
+    const defaultSchemaOut = path.join(configFolderPath, (cli as any).controller!.config?.schemaConfig?.outputDirectory || 'schemas');
+    const { schemaOutDir } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'schemaOutDir',
+        message: 'Output directory for schemas:',
+        default: defaultSchemaOut,
+        validate: (input: string) => 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 as any).controller!.config!, configFolderPath);
+    const outDirRel = path.isAbsolute(schemaOutDir) ? schemaOutDir : path.relative(configFolderPath, schemaOutDir);
+    await schemaGenerator.generateSchemas({ format: schemaType as any, verbose: true, outputDir: outDirRel });
 
     MessageFormatter.success("Schema generation completed", { prefix: "Schemas" });
   },
 
-  async generateConstants(cli: InteractiveCLI): Promise<void> {
+  async generateConstants(cli: InteractiveCLI): Promise<void> {
     MessageFormatter.progress("Generating cross-language constants...", { prefix: "Constants" });
 
     if (!(cli as any).controller?.config) {
@@ -48,8 +63,8 @@ export const schemaCommands = {
       return;
     }
 
-    // Prompt for languages
-    const { languages } = await inquirer.prompt([
+    // Prompt for languages
+    const { languages } = await inquirer.prompt([
       {
         type: "checkbox",
         name: "languages",
@@ -70,7 +85,23 @@ export const schemaCommands = {
           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 as any).controller!.getAppwriteFolderPath();
@@ -98,8 +129,14 @@ export const schemaCommands = {
       const { ConstantsGenerator } = await import("../../utils/constantsGenerator.js");
       const generator = new ConstantsGenerator((cli as any).controller.config);
 
-      MessageFormatter.info(`Generating constants for: ${languages.join(", ")}`, { prefix: "Constants" });
-      await generator.generateFiles(languages, outputDir);
+      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) {

package/src/cli/commands/storageCommands.ts

@@ -0,0 +1,152 @@
+import inquirer from "inquirer";
+import chalk from "chalk";
+import { Storage, Permission, Role, Compression, type Models } from "node-appwrite";
+import type { InteractiveCLI } from "../../interactiveCLI.js";
+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: InteractiveCLI): Promise<void> {
+    const storage: Storage = (cli as any).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:string)=> 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: string[] = [];
+    if (answers.publicRead) permissions.push(Permission.read(Role.any()));
+
+    const bucketInput: Omit<Models.Bucket, "$id" | "$createdAt" | "$updatedAt"> = {
+      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 as Compression,
+      encryption: !!answers.encryption,
+      antivirus: !!answers.antivirus,
+    } as any;
+
+    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 as any).controller!;
+      controller.config.buckets = controller.config.buckets || [];
+      controller.config.buckets.push({
+        $id: (created as any).$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: InteractiveCLI): Promise<void> {
+    const storage: Storage = (cli as any).controller!.storage!;
+    if (!storage) {
+      MessageFormatter.error("Storage client not initialized", undefined, { prefix: "Buckets" });
+      return;
+    }
+
+    try {
+      const res = await listBuckets(storage);
+      const buckets: Models.Bucket[] = 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 as any).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: any) => b.$id !== id);
+          }
+          // Clear database-linked bucket references if matching
+          if (Array.isArray(controller.config.databases)) {
+            controller.config.databases = controller.config.databases.map((db: any) => ({
+              ...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' });
+    }
+  }
+};