appwrite-utils-cli 1.9.7 → 1.12.0

package/dist/shared/operationsTableSchema.js

@@ -24,12 +24,12 @@ export const OperationRecordSchema = z.object({
     $createdAt: z.string(),
     $updatedAt: z.string(),
     operationType: z.string(),
-    targetCollection: z.string().optional(),
+    targetTable: z.string().optional(),
     status: OperationStatusSchema,
     progress: z.number(),
     total: z.number(),
     data: z.any().optional(),
     error: z.string().optional()
 });
-export const OPERATIONS_TABLE_ID = "_appwrite_operations";
+export const OPERATIONS_TABLE_ID = "appwrite_operations";
 export const OPERATIONS_TABLE_NAME = "Operations Tracking";

package/dist/shared/progressManager.js

@@ -1,6 +1,6 @@
 import cliProgress from "cli-progress";
 import chalk from "chalk";
-import { MessageFormatter } from "./messageFormatter.js";
+import { MessageFormatter } from 'appwrite-utils-helpers';
 export class ProgressManager {
     static instances = new Map();
     bar;

package/dist/shared/selectionDialogs.d.ts

@@ -179,6 +179,12 @@ export declare class SelectionDialogs {
      * Shows bucket selection dialog for selected databases
      */
     static selectBucketsForDatabases(selectedDatabaseIds: string[], availableBuckets: any[], configuredBuckets: any[], options?: BucketSelectionOptions): Promise<string[]>;
+    /**
+     * Shows bucket selection for push operations with merged local+remote buckets.
+     * Unlike selectBucketsForDatabases, this shows all buckets as a flat list
+     * with source indicators (Local only, Remote only, Configured).
+     */
+    static selectBucketsForPush(mergedBuckets: any[], configuredBuckets: any[], options?: BucketSelectionOptions): Promise<string[]>;
     /**
      * Shows final confirmation dialog with sync selection summary
      */

package/dist/shared/selectionDialogs.js

@@ -1,7 +1,7 @@
 import inquirer from "inquirer";
 import chalk from "chalk";
-import { MessageFormatter } from "./messageFormatter.js";
-import { logger } from "./logging.js";
+import { MessageFormatter } from 'appwrite-utils-helpers';
+import { logger } from 'appwrite-utils-helpers';
 /**
  * Comprehensive selection dialog system for enhanced sync flow
  *
@@ -186,7 +186,7 @@ export class SelectionDialogs {
         if (showDatabaseContext) {
             MessageFormatter.section(`Table Selection for ${databaseName}`);
         }
-        const configuredIds = new Set(configuredTables.map(table => table.$id || table.id));
+        const configuredIds = new Set(configuredTables.map(table => table.$id || table.id || table.tableId || table.name));
         let choices = [];
         if (showSelectAll && availableTables.length > 1) {
             choices.push({
@@ -196,18 +196,19 @@ export class SelectionDialogs {
             });
         }
         availableTables.forEach(table => {
-            const isConfigured = configuredIds.has(table.$id);
+            const tableId = table.$id || table.id || table.tableId || table.name;
+            const isConfigured = configuredIds.has(tableId);
             const status = isConfigured ? chalk.green('✅') : chalk.blue('○');
-            const name = `${status} ${table.name} (${table.$id})`;
+            const name = `${status} ${table.name} (${tableId})`;
             if (allowNewOnly && isConfigured) {
                 return; // Skip configured tables if only allowing new ones
             }
             choices.push({
                 name,
-                value: table.$id,
+                value: tableId,
                 short: table.name,
                 // Do not preselect anything unless explicitly provided
-                checked: defaultSelected.includes(table.$id)
+                checked: defaultSelected.includes(tableId)
             });
         });
         if (choices.length === 0) {
@@ -231,7 +232,7 @@ export class SelectionDialogs {
             }]);
         // Handle select all
         if (selectedTableIds.includes('__SELECT_ALL__')) {
-            const allIds = availableTables.map(table => table.$id);
+            const allIds = availableTables.map(table => table.$id || table.id || table.tableId || table.name);
             if (allowNewOnly) {
                 return allIds.filter(id => !configuredIds.has(id));
             }
@@ -360,6 +361,46 @@ export class SelectionDialogs {
         }
         return selectedBucketIds || [];
     }
+    /**
+     * Shows bucket selection for push operations with merged local+remote buckets.
+     * Unlike selectBucketsForDatabases, this shows all buckets as a flat list
+     * with source indicators (Local only, Remote only, Configured).
+     */
+    static async selectBucketsForPush(mergedBuckets, configuredBuckets, options = {}) {
+        MessageFormatter.section("Storage Bucket Selection");
+        if (mergedBuckets.length === 0) {
+            MessageFormatter.warning("No storage buckets found (local or remote).", { skipLogging: true });
+            return [];
+        }
+        const choices = mergedBuckets.map(bucket => {
+            let status;
+            let suffix = '';
+            if (bucket._isLocalOnly) {
+                status = chalk.yellow('*');
+                suffix = chalk.yellow(' (Local only - will be created)');
+            }
+            else if (bucket._isRemoteOnly) {
+                status = chalk.blue('○');
+                suffix = chalk.blue(' (Remote only)');
+            }
+            else {
+                status = chalk.green('✅');
+                suffix = chalk.green(' (Configured)');
+            }
+            return {
+                name: `${status} ${bucket.name} (${bucket.$id})${suffix}`,
+                value: bucket.$id,
+                short: bucket.name,
+            };
+        });
+        const { selectedBucketIds } = await inquirer.prompt([{
+                type: 'checkbox',
+                name: 'selectedBucketIds',
+                message: 'Select storage buckets to push:',
+                choices,
+            }]);
+        return selectedBucketIds || [];
+    }
     /**
      * Shows final confirmation dialog with sync selection summary
      */
@@ -402,7 +443,7 @@ export class SelectionDialogs {
             });
         }
         // Table summary
-        console.log(chalk.bold.cyan("\n📋 Tables/Collections:"));
+        console.log(chalk.bold.cyan("\n📋 Tables:"));
         console.log(`  Total: ${selectionSummary.totalTables}`);
         console.log(`  ${chalk.green('✅ Configured')}: ${selectionSummary.existingItems.tables}`);
         console.log(`  ${chalk.blue('○ New')}: ${selectionSummary.newItems.tables}`);
@@ -499,9 +540,12 @@ export class SelectionDialogs {
     static createBucketSelection(selectedBucketIds, availableBuckets, configuredBuckets, availableDatabases) {
         const configuredIds = new Set(configuredBuckets.map(bucket => bucket.$id || bucket.id));
         return selectedBucketIds.map(bucketId => {
-            const bucket = availableBuckets.find(b => b.$id === bucketId);
+            // Look up in availableBuckets first, then fall back to configuredBuckets
+            // (handles merged lists where local-only buckets may only be in configuredBuckets)
+            const bucket = availableBuckets.find(b => b.$id === bucketId)
+                || configuredBuckets.find(b => (b.$id || b.id) === bucketId);
             if (!bucket) {
-                throw new Error(`Bucket with ID ${bucketId} not found in available buckets`);
+                throw new Error(`Bucket with ID ${bucketId} not found in available or configured buckets`);
             }
             const database = bucket.databaseId ?
                 availableDatabases.find(db => db.$id === bucket.databaseId) : undefined;
@@ -510,7 +554,7 @@ export class SelectionDialogs {
                 bucketName: bucket.name,
                 databaseId: bucket.databaseId,
                 databaseName: database?.name,
-                isNew: !configuredIds.has(bucketId)
+                isNew: bucket._isLocalOnly || !configuredIds.has(bucketId)
             };
         });
     }

package/dist/storage/methods.d.ts

@@ -9,7 +9,19 @@ export declare const deleteBucket: (storage: Storage, bucketId: string) => Promi
 export declare const getFile: (storage: Storage, bucketId: string, fileId: string) => Promise<Models.File>;
 export declare const listFiles: (storage: Storage, bucketId: string, queries?: string[], search?: string) => Promise<Models.FileList>;
 export declare const deleteFile: (storage: Storage, bucketId: string, fileId: string) => Promise<{}>;
+/**
+ * Convert permission objects ({permission, target}) to Appwrite Permission strings.
+ */
+export declare const buildPermissionStrings: (permissions: Array<{
+    permission: string;
+    target: string;
+}> | undefined) => string[];
 export declare const ensureDatabaseConfigBucketsExist: (storage: Storage, config: AppwriteConfig, databases?: Models.Database[]) => Promise<void>;
+/**
+ * Ensure global/root-level buckets from config.buckets[] exist on remote.
+ * Optionally filter to only push selected bucket IDs.
+ */
+export declare const ensureGlobalBucketsExist: (storage: Storage, config: AppwriteConfig, selectedBucketIds?: string[]) => Promise<void>;
 export declare const wipeDocumentStorage: (storage: Storage, bucketId: string, options?: {
     skipConfirmation?: boolean;
 }) => Promise<void>;

package/dist/storage/methods.js

@@ -1,15 +1,15 @@
 import { Compression, Databases, Permission, Query, Role, Storage, } from "node-appwrite";
 import { tryAwaitWithRetry } from "appwrite-utils";
-import { getClientFromConfig } from "../utils/getClientFromConfig.js";
+import { getClientFromConfig } from "appwrite-utils-helpers";
 import { ulid } from "ulidx";
 import { logOperation } from "../shared/operationLogger.js";
 import { splitIntoBatches } from "../shared/migrationHelpers.js";
-import { retryFailedPromises } from "../utils/retryFailedPromises.js";
+import { retryFailedPromises } from "appwrite-utils-helpers";
 import { InputFile } from "node-appwrite/file";
-import { MessageFormatter, Messages } from "../shared/messageFormatter.js";
+import { MessageFormatter, Messages } from "appwrite-utils-helpers";
 import { ProgressManager } from "../shared/progressManager.js";
 import { recordBackup } from "../shared/backupTracking.js";
-import { AdapterFactory } from "../adapters/AdapterFactory.js";
+import { AdapterFactory } from "appwrite-utils-helpers";
 import { createBackupZip } from "./backupCompression.js";
 export const getStorage = (config) => {
     const client = getClientFromConfig(config);
@@ -39,96 +39,99 @@ export const listFiles = async (storage, bucketId, queries, search) => {
 export const deleteFile = async (storage, bucketId, fileId) => {
     return await storage.deleteFile(bucketId, fileId);
 };
+/**
+ * Convert permission objects ({permission, target}) to Appwrite Permission strings.
+ */
+export const buildPermissionStrings = (permissions) => {
+    const result = [];
+    if (!permissions || permissions.length === 0)
+        return result;
+    for (const p of permissions) {
+        switch (p.permission) {
+            case 'read':
+                result.push(Permission.read(p.target));
+                break;
+            case 'create':
+                result.push(Permission.create(p.target));
+                break;
+            case 'update':
+                result.push(Permission.update(p.target));
+                break;
+            case 'delete':
+                result.push(Permission.delete(p.target));
+                break;
+            case 'write':
+                result.push(Permission.write(p.target));
+                break;
+            default: break;
+        }
+    }
+    return result;
+};
+/**
+ * Check if a bucket's current state differs from desired config.
+ */
+const bucketDiffers = (existing, desired, permissions) => {
+    return (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);
+};
+/**
+ * Create or update a single bucket to match desired config.
+ */
+const ensureSingleBucketExists = async (storage, desired) => {
+    const permissions = buildPermissionStrings(desired.permissions);
+    try {
+        const existing = await storage.getBucket(desired.$id);
+        if (bucketDiffers(existing, desired, permissions)) {
+            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) {
+        // Bucket doesn't exist, create it
+        try {
+            await storage.createBucket(desired.$id, desired.name, permissions, desired.fileSecurity, desired.enabled, desired.maximumFileSize, desired.allowedFileExtensions, desired.compression, desired.encryption, desired.antivirus);
+            MessageFormatter.success(`Bucket ${desired.$id} created`, { prefix: 'Buckets' });
+        }
+        catch (createError) {
+            MessageFormatter.error(`Failed to create bucket ${desired.$id}`, createError instanceof Error ? createError : new Error(String(createError)), { prefix: 'Buckets' });
+        }
+    }
+};
 export const ensureDatabaseConfigBucketsExist = async (storage, config, databases = []) => {
     for (const db of databases) {
         const database = config.databases?.find((d) => d.$id === db.$id);
         if (database?.bucket) {
-            try {
-                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 = [];
-                if (database.bucket.permissions &&
-                    database.bucket.permissions.length > 0) {
-                    for (const permission of database.bucket.permissions) {
-                        switch (permission.permission) {
-                            case "read":
-                                permissions.push(Permission.read(permission.target));
-                                break;
-                            case "create":
-                                permissions.push(Permission.create(permission.target));
-                                break;
-                            case "update":
-                                permissions.push(Permission.update(permission.target));
-                                break;
-                            case "delete":
-                                permissions.push(Permission.delete(permission.target));
-                                break;
-                            case "write":
-                                permissions.push(Permission.write(permission.target));
-                                break;
-                            default:
-                                console.warn(`Unknown permission: ${permission.permission}`);
-                                break;
-                        }
-                    }
-                }
-                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);
-                    MessageFormatter.success(`Bucket ${database.bucket.$id} created`, { prefix: 'Buckets' });
-                }
-                catch (createError) {
-                    MessageFormatter.error(`Failed to create bucket ${database.bucket.$id}`, createError instanceof Error ? createError : new Error(String(createError)), { prefix: 'Buckets' });
-                }
-            }
+            await ensureSingleBucketExists(storage, database.bucket);
+        }
+    }
+};
+/**
+ * Ensure global/root-level buckets from config.buckets[] exist on remote.
+ * Optionally filter to only push selected bucket IDs.
+ */
+export const ensureGlobalBucketsExist = async (storage, config, selectedBucketIds) => {
+    const globalBuckets = config.buckets || [];
+    for (const bucket of globalBuckets) {
+        if (selectedBucketIds && !selectedBucketIds.includes(bucket.$id)) {
+            continue;
         }
+        await ensureSingleBucketExists(storage, bucket);
     }
 };
 export const wipeDocumentStorage = async (storage, bucketId, options = {}) => {

package/dist/storage/schemas.d.ts

@@ -12,11 +12,11 @@ export declare const BackupSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type Backup = z.infer<typeof BackupSchema>;
 export declare const BackupCreateSchema: z.ZodObject<{
+    collections: z.ZodArray<z.ZodString>;
     documents: z.ZodDefault<z.ZodArray<z.ZodObject<{
         collectionId: z.ZodString;
         data: z.ZodString;
     }, z.core.$strip>>>;
-    collections: z.ZodArray<z.ZodString>;
     database: z.ZodString;
 }, z.core.$strip>;
 export type BackupCreate = z.infer<typeof BackupCreateSchema>;
@@ -56,7 +56,6 @@ export declare const OperationSchema: z.ZodObject<{
 export type Operation = z.infer<typeof OperationSchema>;
 export declare const OperationCreateSchema: z.ZodObject<{
     error: z.ZodString;
-    data: z.ZodAny;
     status: z.ZodDefault<z.ZodEnum<{
         error: "error";
         pending: "pending";
@@ -66,6 +65,7 @@ export declare const OperationCreateSchema: z.ZodObject<{
         cancelled: "cancelled";
     }>>;
     collectionId: z.ZodString;
+    data: z.ZodAny;
     operationType: z.ZodString;
     batches: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString>>>;
     progress: z.ZodNumber;

package/dist/tables/indexManager.d.ts

@@ -1,5 +1,5 @@
 import type { Index } from "appwrite-utils";
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import type { DatabaseAdapter } from "appwrite-utils-helpers";
 import type { Models } from "node-appwrite";
 export interface IndexOperation {
     type: 'create' | 'update' | 'skip' | 'delete';

package/dist/tables/indexManager.js

@@ -1,6 +1,6 @@
 import { isIndexEqualToIndex } from "../collections/tableOperations.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-import { delay, tryAwaitWithRetry } from "../utils/helperFunctions.js";
+import { MessageFormatter } from "appwrite-utils-helpers";
+import { delay, tryAwaitWithRetry } from "appwrite-utils-helpers";
 /**
  * Plan index operations by comparing desired indexes with existing ones
  * Uses the existing isIndexEqualToIndex function for consistent comparison

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-export type { ValidationRules } from "./utils/validationRules.js";
+export type { ValidationRules } from "appwrite-utils-helpers";
 export { type AuthUserCreate, AuthUserCreateSchema, type AuthUser, AuthUserSchema, } from "./schemas/authUser.js";
-export { validationRules } from "./utils/validationRules.js";
+export { validationRules } from "appwrite-utils-helpers";
 export { afterImportActions } from "./migrations/afterImportActions.js";

package/dist/types.js

@@ -1,3 +1,3 @@
 export { AuthUserCreateSchema, AuthUserSchema, } from "./schemas/authUser.js";
-export { validationRules } from "./utils/validationRules.js";
+export { validationRules } from "appwrite-utils-helpers";
 export { afterImportActions } from "./migrations/afterImportActions.js";

package/dist/users/methods.js

@@ -1,11 +1,10 @@
 import { AppwriteException, Databases, ID, Query, Users, } from "node-appwrite";
 import { AuthUserSchema, } from "../schemas/authUser.js";
-import { logger } from "../shared/logging.js";
+import { logger, MessageFormatter } from "appwrite-utils-helpers";
 import { splitIntoBatches } from "../shared/migrationHelpers.js";
-import { getAppwriteClient, tryAwaitWithRetry, } from "../utils/helperFunctions.js";
+import { getAppwriteClient, tryAwaitWithRetry, } from "appwrite-utils-helpers";
 import { isUndefined } from "es-toolkit/compat";
 import { isEmpty } from "es-toolkit/compat";
-import { MessageFormatter } from "../shared/messageFormatter.js";
 export class UsersController {
     config;
     users;

package/dist/utils/configMigration.js

@@ -1,7 +1,7 @@
 import { promises as fs } from "fs";
 import path from "path";
 import { existsSync } from "fs";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { MessageFormatter } from "appwrite-utils-helpers";
 import { ConfirmationDialogs } from "../shared/confirmationDialogs.js";
 import yaml from "js-yaml";
 export async function migrateConfig(workingDir) {

package/dist/utils/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./helperFunctions.js";
+export * from 'appwrite-utils-helpers';
 export * from "./setupFiles.js";

package/dist/utils/index.js

@@ -1,2 +1,2 @@
-export * from "./helperFunctions.js";
+export * from 'appwrite-utils-helpers';
 export * from "./setupFiles.js";

package/dist/utils/loadConfigs.d.ts

@@ -1,5 +1,5 @@
 import { type AppwriteConfig } from "appwrite-utils";
-import { type ValidationResult } from "../config/configValidation.js";
+import { type ValidationResult } from "appwrite-utils-helpers";
 /**
  * Session authentication preservation options for config loading
  */
@@ -28,7 +28,7 @@ export interface ConfigLoadingOptions {
  * @returns SessionPreservationOptions object
  */
 export declare function createSessionPreservation(sessionCookie: string, email?: string, expiresAt?: string): SessionPreservationOptions;
-export { findAppwriteConfig, findFunctionsDir } from "./configDiscovery.js";
+export { findAppwriteConfig, findFunctionsDir } from 'appwrite-utils-helpers';
 /**
  * Loads the Appwrite configuration and returns both config and the path where it was found.
  * @param configDir The directory to search for config files.

package/dist/utils/loadConfigs.js

@@ -4,12 +4,11 @@ import {} from "appwrite-utils";
 import { register } from "tsx/esm/api"; // Import the register function
 import { pathToFileURL } from "node:url";
 import chalk from "chalk";
-import { findYamlConfig, loadYamlConfig, loadYamlConfigWithSession, extractSessionOptionsFromConfig } from "../config/yamlConfig.js";
-import { detectAppwriteVersionCached, fetchServerVersion, isVersionAtLeast } from "./versionDetection.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-import { validateCollectionsTablesConfig, reportValidationResults } from "../config/configValidation.js";
-import { resolveCollectionsDir, resolveTablesDir } from "./pathResolvers.js";
-import { findAppwriteConfig, findAppwriteConfigTS, findFunctionsDir, discoverCollections, discoverTables, discoverLegacyDirectory } from "./configDiscovery.js";
+import { findYamlConfig, loadYamlConfig, loadYamlConfigWithSession, extractSessionOptionsFromConfig, validateCollectionsTablesConfig, reportValidationResults } from "appwrite-utils-helpers";
+import { detectAppwriteVersionCached, fetchServerVersion, isVersionAtLeast } from 'appwrite-utils-helpers';
+import { MessageFormatter } from "appwrite-utils-helpers";
+import { resolveCollectionsDir, resolveTablesDir } from 'appwrite-utils-helpers';
+import { findAppwriteConfig, findAppwriteConfigTS, findFunctionsDir, discoverCollections, discoverTables, discoverLegacyDirectory } from 'appwrite-utils-helpers';
 /**
  * Helper function to create session preservation options from session data
  * @param sessionCookie The session cookie string
@@ -28,7 +27,7 @@ export function createSessionPreservation(sessionCookie, email, expiresAt) {
     };
 }
 // Re-export config discovery functions for backward compatibility
-export { findAppwriteConfig, findFunctionsDir } from "./configDiscovery.js";
+export { findAppwriteConfig, findFunctionsDir } from 'appwrite-utils-helpers';
 /**
  * Loads the Appwrite configuration and returns both config and the path where it was found.
  * @param configDir The directory to search for config files.