appwrite-utils-cli 1.8.7 → 1.8.9

package/CHANGELOG.md

@@ -17,3 +17,19 @@ All notable changes to this project will be documented in this file.
   - Output directory selectable during interactive flow (absolute paths respected)
 - Constants generator now supports selecting which categories to include (databases, collections/tables, buckets, functions).
 - Bucket management: interactive create/delete commands with YAML persistence when active; selective push now diffs and updates bucket settings (name, permissions, security, limits).
+
+## 1.8.8 - 2025-10-29
+
+- Fix: Selective push processed state is tracked per database. Previously, pushing the same table to multiple databases could skip the second database with “already processed”; now each DB is handled independently.
+- Fix: Clear in-memory processing state between databases during multi-DB pushes to prevent cross-database leakage of IDs and processed flags.
+- Enhancement: Interactive selection adds “Use same selection as before” when choosing tables per database, speeding up multi-DB workflows.
+- Behavior: Non-interactive `--push` with both `--dbIds` and `--collectionIds` is fully non-interactive. The provided IDs are applied as-is to every selected database and the confirmation summary is skipped.
+- Improvement: Selective push reloads local config from disk before pushing to ensure the latest YAML/TS changes are used.
+- Fix: Sync-from-Appwrite now captures function `scopes` and writes them to config; deployments use `scopes` from either central config or `.fnconfig.yaml`.
+- Change: Removed global prompt to choose between central `config.yaml` and per-function `.fnconfig.yaml` during function deployments. The tool now prompts per function only when both sources exist for that function (with an option to merge where `.fnconfig` overrides).
+
+## 1.8.9 - 2025-10-29
+
+- Fix: Functions sync now fetches full details via `getFunction` per function to reliably capture `scopes` (prevents empty scopes in some environments).
+- Confirmed schema: YAML `appwrite-config.schema.json` supports `functions[].dirPath`; writers preserve `dirPath` when present.
+- Polish: Per-function config source selection is now applied at deploy time when both central and `.fnconfig.yaml` are present.

package/dist/cli/commands/functionCommands.js

@@ -111,38 +111,14 @@ export const functionCommands = {
             MessageFormatter.error("Failed to initialize controller or load config", undefined, { prefix: "Functions" });
             return;
         }
-        // Offer choice of function config sources: central YAML, .fnconfig.yaml, or both
-        let sourceChoice = 'both';
+        // 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 {
-            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.currentDir);
-            const central = cli.controller.config.functions || [];
-            if (sourceChoice === 'central') {
-                cli.controller.config.functions = central;
-            }
-            else if (sourceChoice === 'fnconfig') {
-                cli.controller.config.functions = discovered;
-            }
-            else {
-                const merged = mergeDiscoveredFunctions(central, discovered);
-                cli.controller.config.functions = merged;
-            }
+            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);
@@ -155,22 +131,51 @@ export const functionCommands = {
                 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 = functionConfig.name
+            const functionNameLower = effectiveConfig.name
                 .toLowerCase()
                 .replace(/\s+/g, "-");
             // Debug logging
             MessageFormatter.info(`🔍 Function deployment debug:`, { prefix: "Functions" });
-            MessageFormatter.info(`  Function name: ${functionConfig.name}`, { prefix: "Functions" });
-            MessageFormatter.info(`  Function ID: ${functionConfig.$id}`, { prefix: "Functions" });
-            MessageFormatter.info(`  Config dirPath: ${functionConfig.dirPath || 'undefined'}`, { prefix: "Functions" });
-            if (functionConfig.dirPath) {
-                const expandedPath = functionConfig.dirPath.startsWith('~/')
-                    ? functionConfig.dirPath.replace('~', os.homedir())
-                    : functionConfig.dirPath;
+            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" });
@@ -182,10 +187,10 @@ export const functionCommands = {
             // Check locations in priority order:
             const priorityLocations = [
                 // 1. Config dirPath if specified (with tilde expansion)
-                functionConfig.dirPath
-                    ? (require('node:path').isAbsolute(expandTildePath(functionConfig.dirPath))
-                        ? expandTildePath(functionConfig.dirPath)
-                        : require('node:path').resolve(yamlBaseDir, expandTildePath(functionConfig.dirPath)))
+                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),
@@ -226,10 +231,10 @@ export const functionCommands = {
                 if (shouldDownload) {
                     try {
                         MessageFormatter.progress("Downloading latest deployment...", { prefix: "Functions" });
-                        const { path: downloadedPath, function: remoteFunction } = await downloadLatestFunctionDeployment(cli.controller.appwriteServer, functionConfig.$id, join(cli.controller.getAppwriteFolderPath(), "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;
-                        functionConfig.dirPath = 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 =
@@ -243,7 +248,7 @@ export const functionCommands = {
                     }
                 }
                 else {
-                    MessageFormatter.error(`Function ${functionConfig.name} not found locally. Cannot deploy.`, undefined, { prefix: "Functions" });
+                    MessageFormatter.error(`Function ${effectiveConfig.name} not found locally. Cannot deploy.`, undefined, { prefix: "Functions" });
                     return;
                 }
             }
@@ -252,8 +257,8 @@ export const functionCommands = {
                 return;
             }
             try {
-                await deployLocalFunction(cli.controller.appwriteServer, functionConfig.name, {
-                    ...functionConfig,
+                await deployLocalFunction(cli.controller.appwriteServer, effectiveConfig.name, {
+                    ...effectiveConfig,
                     dirPath: functionPath,
                 }, functionPath);
                 MessageFormatter.success("Function deployed successfully!", { prefix: "Functions" });

package/dist/collections/attributes.js

@@ -1222,7 +1222,7 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
     // Filter to only attributes that need processing (new, changed, or not yet processed)
     const attributesToProcess = attributes.filter((attribute) => {
         // Skip if already processed in this session
-        if (isAttributeProcessed(currentCollection.$id, attribute.key)) {
+        if (isAttributeProcessed(dbId, currentCollection.$id, attribute.key)) {
             return false;
         }
         const existing = existingAttributesMap.get(attribute.key);
@@ -1253,7 +1253,7 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (db, dbId,
             const success = await createOrUpdateAttributeWithStatusCheck(db, dbId, currentCollection, attribute);
             if (success) {
                 // Mark this specific attribute as processed
-                markAttributeProcessed(currentCollection.$id, attribute.key);
+                markAttributeProcessed(dbId, currentCollection.$id, attribute.key);
                 // Get updated collection data for next iteration
                 try {
                     currentCollection = isDatabaseAdapter(db)

package/dist/collections/methods.js

@@ -149,8 +149,8 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
     const relQueue = [];
     for (const collection of collectionsToProcess) {
         const { attributes, indexes, ...collectionData } = collection;
-        // Check if this table has already been processed in this session
-        if (collectionData.$id && isCollectionProcessed(collectionData.$id)) {
+        // Check if this table has already been processed in this session (per database)
+        if (collectionData.$id && isCollectionProcessed(collectionData.$id, databaseId)) {
             MessageFormatter.info(`Table '${collectionData.name}' already processed, skipping`, { prefix: "Tables" });
             continue;
         }
@@ -602,8 +602,8 @@ export const createOrUpdateCollectionsViaAdapter = async (adapter, databaseId, c
         catch (e) {
             MessageFormatter.warning(`Could not evaluate deletions: ${e?.message || e}`, { prefix: 'Attributes' });
         }
-        // Mark this table as fully processed to prevent re-processing
-        markCollectionProcessed(tableId, collectionData.name);
+        // Mark this table as fully processed for this database to prevent re-processing in the same DB only
+        markCollectionProcessed(tableId, collectionData.name, databaseId);
     }
     // Process queued relationships once mapping likely populated
     if (relQueue.length > 0) {

package/dist/interactiveCLI.d.ts

@@ -2,6 +2,7 @@ export declare class InteractiveCLI {
     private currentDir;
     private controller;
     private isUsingTypeScriptConfig;
+    private lastSelectedCollectionIds;
     constructor(currentDir: string);
     run(): Promise<void>;
     private initControllerIfNeeded;

package/dist/interactiveCLI.js

@@ -52,6 +52,7 @@ export class InteractiveCLI {
     currentDir;
     controller;
     isUsingTypeScriptConfig = false;
+    lastSelectedCollectionIds = [];
     constructor(currentDir) {
         this.currentDir = currentDir;
     }
@@ -382,25 +383,41 @@ export class InteractiveCLI {
         }
         // Show current database context clearly before view mode selection
         MessageFormatter.info(`DB: ${database.name}`, { prefix: "Collections" });
-        // Ask user if they want to filter by database or show all
+        // Ask user if they want to filter by database, show all, or reuse previous selection
+        const choices = [
+            {
+                name: `Show all available collections/tables (${totalCount} total) - You can push any collection to any database`,
+                value: "all"
+            },
+            {
+                name: `Filter by database "${database.name}" - Show only related collections/tables`,
+                value: "filter"
+            }
+        ];
+        if (this.lastSelectedCollectionIds && this.lastSelectedCollectionIds.length > 0) {
+            choices.unshift({
+                name: `Use same selection as before (${this.lastSelectedCollectionIds.length} items)`,
+                value: "same"
+            });
+        }
         const { filterChoice } = await inquirer.prompt([
             {
                 type: "list",
                 name: "filterChoice",
                 message: chalk.blue("How would you like to view collections/tables?"),
-                choices: [
-                    {
-                        name: `Show all available collections/tables (${totalCount} total) - You can push any collection to any database`,
-                        value: "all"
-                    },
-                    {
-                        name: `Filter by database "${database.name}" - Show only related collections/tables`,
-                        value: "filter"
-                    }
-                ],
-                default: "all"
+                choices,
+                default: choices[0]?.value || "all"
             }
         ]);
+        // If user wants to reuse the previous selection, map IDs to current config and return
+        if (filterChoice === "same") {
+            const map = new Map(this.getLocalCollections().map((c) => [c.$id || c.id, c]));
+            const selected = this.lastSelectedCollectionIds
+                .map((id) => map.get(id))
+                .filter((c) => !!c);
+            MessageFormatter.info(`Using same selection as previous: ${selected.length} item(s)`, { prefix: "Collections" });
+            return selected;
+        }
         // User's choice overrides the parameter
         const userWantsFiltering = filterChoice === "filter";
         // Show appropriate informational message
@@ -416,7 +433,10 @@ export class InteractiveCLI {
         else {
             MessageFormatter.info(`ℹ️  Showing all available collections/tables - you can push any collection to any database\n`, { prefix: "Collections" });
         }
-        return this.selectCollections(database, databasesClient, message, multiSelect, preferLocal, userWantsFiltering);
+        const result = await this.selectCollections(database, databasesClient, message, multiSelect, preferLocal, userWantsFiltering);
+        // Remember this selection for subsequent databases
+        this.lastSelectedCollectionIds = (result || []).map((c) => c.$id || c.id);
+        return result;
     }
     getTemplateDefaults(template) {
         const defaults = {

package/dist/main.js

@@ -964,6 +964,7 @@ async function main() {
             // Build DatabaseSelection[] with tableIds per DB
             const databaseSelections = [];
             const allConfigItems = controller.config.collections || controller.config.tables || [];
+            let lastSelectedTableIds = null;
             for (const dbId of selectedDbIds) {
                 const db = availableDatabases.find(d => d.$id === dbId);
                 if (!db)
@@ -983,13 +984,39 @@ async function main() {
                 // Determine selected table IDs
                 let selectedTableIds = [];
                 if (parsedArgv.collectionIds) {
-                    const ids = parsedArgv.collectionIds.split(/[,\s]+/).filter(Boolean);
-                    // Only allow IDs that are in eligible config items
-                    const eligibleIds = new Set(eligibleConfigItems.map((c) => c.$id || c.id));
-                    selectedTableIds = ids.filter(id => eligibleIds.has(id));
+                    // Non-interactive: respect provided table IDs as-is (apply to each selected DB)
+                    selectedTableIds = parsedArgv.collectionIds.split(/[\,\s]+/).filter(Boolean);
                 }
                 else {
-                    selectedTableIds = await SelectionDialogs.selectTablesForDatabase(dbId, db.name, availableTables, eligibleConfigItems, { showSelectAll: false, allowNewOnly: true, defaultSelected: [] });
+                    // If we have a previous selection, offer to reuse it
+                    if (lastSelectedTableIds && lastSelectedTableIds.length > 0) {
+                        const inquirer = (await import("inquirer")).default;
+                        const { reuseMode } = await inquirer.prompt([
+                            {
+                                type: "list",
+                                name: "reuseMode",
+                                message: `How do you want to select tables for ${db.name}?`,
+                                choices: [
+                                    { name: `Use same selection as previous (${lastSelectedTableIds.length} items)`, value: "same" },
+                                    { name: `Filter by this database (manual select)`, value: "filter" },
+                                    { name: `Show all available in this database (manual select)`, value: "all" }
+                                ],
+                                default: "same"
+                            }
+                        ]);
+                        if (reuseMode === "same") {
+                            selectedTableIds = [...lastSelectedTableIds];
+                        }
+                        else if (reuseMode === "all") {
+                            selectedTableIds = await SelectionDialogs.selectTablesForDatabase(dbId, db.name, availableTables, allConfigItems, { showSelectAll: false, allowNewOnly: false, defaultSelected: lastSelectedTableIds });
+                        }
+                        else {
+                            selectedTableIds = await SelectionDialogs.selectTablesForDatabase(dbId, db.name, availableTables, eligibleConfigItems, { showSelectAll: false, allowNewOnly: true, defaultSelected: lastSelectedTableIds });
+                        }
+                    }
+                    else {
+                        selectedTableIds = await SelectionDialogs.selectTablesForDatabase(dbId, db.name, availableTables, eligibleConfigItems, { showSelectAll: false, allowNewOnly: true, defaultSelected: [] });
+                    }
                 }
                 databaseSelections.push({
                     databaseId: db.$id,
@@ -998,6 +1025,9 @@ async function main() {
                     tableNames: [],
                     isNew: false,
                 });
+                if (!parsedArgv.collectionIds) {
+                    lastSelectedTableIds = selectedTableIds;
+                }
             }
             if (databaseSelections.every(sel => sel.tableIds.length === 0)) {
                 MessageFormatter.warning("No tables/collections selected for push", { prefix: "Push" });
@@ -1008,10 +1038,13 @@ async function main() {
                 collections: databaseSelections.reduce((sum, s) => sum + s.tableIds.length, 0),
                 details: databaseSelections.map(s => `${s.databaseId}: ${s.tableIds.length} items`),
             };
-            const confirmed = await ConfirmationDialogs.showOperationSummary('Push', pushSummary, { confirmationRequired: true });
-            if (!confirmed) {
-                MessageFormatter.info("Push operation cancelled", { prefix: "Push" });
-                return;
+            // Skip confirmation if both dbIds and collectionIds are provided (non-interactive)
+            if (!(parsedArgv.dbIds && parsedArgv.collectionIds)) {
+                const confirmed = await ConfirmationDialogs.showOperationSummary('Push', pushSummary, { confirmationRequired: true });
+                if (!confirmed) {
+                    MessageFormatter.info("Push operation cancelled", { prefix: "Push" });
+                    return;
+                }
             }
             await controller.selectivePush(databaseSelections, []);
             operationStats.pushedDatabases = databaseSelections.length;

package/dist/migrations/appwriteToX.js

@@ -7,7 +7,7 @@ import { CollectionSchema, attributeSchema, AppwriteConfigSchema, permissionsSch
 import { getDatabaseFromConfig } from "./afterImportActions.js";
 import { getAdapterFromConfig } from "../utils/getClientFromConfig.js";
 import { listBuckets } from "../storage/methods.js";
-import { listFunctions, listFunctionDeployments } from "../functions/methods.js";
+import { listFunctions, listFunctionDeployments, getFunction } from "../functions/methods.js";
 import { MessageFormatter } from "../shared/messageFormatter.js";
 import { isLegacyDatabases } from "../utils/typeGuards.js";
 /**
@@ -420,7 +420,18 @@ export class AppwriteToX {
         const remoteFunctions = await listFunctions(this.config.appwriteClient, [
             Query.limit(1000),
         ]);
-        this.updatedConfig.functions = remoteFunctions.functions.map((func) => ({
+        // Fetch full details per function to ensure 'scopes' and other fields are present
+        const detailedFunctions = [];
+        for (const f of remoteFunctions.functions) {
+            try {
+                const full = await getFunction(this.config.appwriteClient, f.$id);
+                detailedFunctions.push(full);
+            }
+            catch {
+                detailedFunctions.push(f);
+            }
+        }
+        this.updatedConfig.functions = detailedFunctions.map((func) => ({
             $id: func.$id,
             name: func.name,
             runtime: func.runtime,
@@ -432,6 +443,7 @@ export class AppwriteToX {
             logging: func.logging !== false,
             entrypoint: func.entrypoint || "src/index.ts",
             commands: func.commands || "npm install",
+            scopes: Array.isArray(func.scopes) ? func.scopes : [],
             dirPath: `functions/${func.name}`,
             specification: func.specification,
         }));

package/dist/shared/operationQueue.d.ts

@@ -20,19 +20,19 @@ export declare const clearProcessingState: () => void;
 /**
  * Check if a collection has already been fully processed
  */
-export declare const isCollectionProcessed: (collectionId: string) => boolean;
+export declare const isCollectionProcessed: (collectionId: string, databaseId: string) => boolean;
 /**
  * Mark a collection as fully processed
  */
-export declare const markCollectionProcessed: (collectionId: string, collectionName?: string) => void;
+export declare const markCollectionProcessed: (collectionId: string, collectionName: string | undefined, databaseId: string) => void;
 /**
  * Check if a specific attribute has been processed
  */
-export declare const isAttributeProcessed: (collectionId: string, attributeKey: string) => boolean;
+export declare const isAttributeProcessed: (databaseId: string, collectionId: string, attributeKey: string) => boolean;
 /**
  * Mark a specific attribute as processed
  */
-export declare const markAttributeProcessed: (collectionId: string, attributeKey: string) => void;
+export declare const markAttributeProcessed: (databaseId: string, collectionId: string, attributeKey: string) => void;
 /**
  * Process only specific attributes in the queue, not entire collections
  * This prevents triggering full collection re-processing cycles

package/dist/shared/operationQueue.js

@@ -7,8 +7,14 @@ import { MessageFormatter } from "../shared/messageFormatter.js";
 // Global state management
 export const queuedOperations = [];
 export const nameToIdMapping = new Map();
+// Keys are scoped per database to avoid cross-database collisions
+// Collections key format: `${databaseId}::${collectionId}`
+// Attributes key format: `${databaseId}::${collectionId}::${attributeKey}`
 export const processedCollections = new Set();
-export const processedAttributes = new Set(); // format: "collectionId:attributeKey"
+export const processedAttributes = new Set();
+// Helpers to build scoped keys
+const collectionKey = (databaseId, collectionId) => `${databaseId}::${collectionId}`;
+const attributeKeyScoped = (databaseId, collectionId, key) => `${databaseId}::${collectionId}::${key}`;
 export const enqueueOperation = (operation) => {
     // Avoid duplicate queue entries for same attribute
     const attributeKey = operation.attribute?.key;
@@ -64,38 +70,40 @@ export const clearProcessingState = () => {
 /**
  * Check if a collection has already been fully processed
  */
-export const isCollectionProcessed = (collectionId) => {
-    return processedCollections.has(collectionId);
+export const isCollectionProcessed = (collectionId, databaseId) => {
+    return processedCollections.has(collectionKey(databaseId, collectionId));
 };
 /**
  * Mark a collection as fully processed
  */
-export const markCollectionProcessed = (collectionId, collectionName) => {
-    processedCollections.add(collectionId);
+export const markCollectionProcessed = (collectionId, collectionName, databaseId) => {
+    processedCollections.add(collectionKey(databaseId, collectionId));
     const logData = {
+        databaseId,
         collectionId,
         collectionName,
         totalProcessedCollections: processedCollections.size,
         operation: 'markCollectionProcessed'
     };
     if (collectionName) {
-        MessageFormatter.success(`Marked collection '${collectionName}' (${collectionId}) as processed`);
+        MessageFormatter.success(`Marked collection '${collectionName}' (${collectionId}) as processed`, { prefix: 'Tables' });
     }
     logger.info('Collection marked as processed', logData);
 };
 /**
  * Check if a specific attribute has been processed
  */
-export const isAttributeProcessed = (collectionId, attributeKey) => {
-    return processedAttributes.has(`${collectionId}:${attributeKey}`);
+export const isAttributeProcessed = (databaseId, collectionId, attributeKey) => {
+    return processedAttributes.has(attributeKeyScoped(databaseId, collectionId, attributeKey));
 };
 /**
  * Mark a specific attribute as processed
  */
-export const markAttributeProcessed = (collectionId, attributeKey) => {
-    const identifier = `${collectionId}:${attributeKey}`;
+export const markAttributeProcessed = (databaseId, collectionId, attributeKey) => {
+    const identifier = attributeKeyScoped(databaseId, collectionId, attributeKey);
     processedAttributes.add(identifier);
     logger.debug('Attribute marked as processed', {
+        databaseId,
         collectionId,
         attributeKey,
         identifier,
@@ -152,8 +160,8 @@ export const processQueue = async (db, dbId) => {
             }
             const attributeKey = operation.attribute.key;
             const collectionId = operation.collectionId;
-            // Skip if this specific attribute was already processed
-            if (isAttributeProcessed(collectionId, attributeKey)) {
+            // Skip if this specific attribute was already processed (per database)
+            if (isAttributeProcessed(dbId, collectionId, attributeKey)) {
                 MessageFormatter.debug(`Attribute '${attributeKey}' already processed, removing from queue`);
                 logger.debug('Removing already processed attribute from queue', {
                     attributeKey,
@@ -268,7 +276,7 @@ export const processQueue = async (db, dbId) => {
                         targetCollectionName: targetCollection.name,
                         operation: 'processQueue'
                     });
-                    markAttributeProcessed(collectionId, attributeKey);
+                    markAttributeProcessed(dbId, collectionId, attributeKey);
                     queuedOperations.splice(i, 1);
                     progress = true;
                 }

package/dist/utilsController.js

@@ -454,6 +454,13 @@ export class UtilsController {
             this.config.apiMode = this.adapter.getApiMode();
             logger.debug(`Updated config.apiMode from adapter: ${this.config.apiMode}`, { prefix: "UtilsController" });
         }
+        // Ensure we don't carry state between databases in a multi-db push
+        // This resets processed sets and name->id mapping per database
+        try {
+            const { clearProcessingState } = await import('./shared/operationQueue.js');
+            clearProcessingState();
+        }
+        catch { }
         // Always prefer adapter path for unified behavior. LegacyAdapter internally translates when needed.
         if (this.adapter) {
             logger.debug("Using adapter for createOrUpdateCollections (unified path)", {

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.7",
+  "version": "1.8.9",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/cli/commands/functionCommands.ts

@@ -138,36 +138,14 @@ export const functionCommands = {
       return;
     }
 
-    // Offer choice of function config sources: central YAML, .fnconfig.yaml, or both
-    let sourceChoice: 'central' | 'fnconfig' | 'both' = 'both';
+    // 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: any[] = [];
+    let central: any[] = (cli as any).controller!.config!.functions || [];
     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 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;
-      }
+      discovered = discoverFnConfigs((cli as any).currentDir) as any[];
+      const merged = mergeDiscoveredFunctions(central as any, discovered as any);
+      (cli as any).controller!.config!.functions = merged as any;
     } catch {}
 
     const functions = await (cli as any).selectFunctions(
@@ -181,32 +159,59 @@ export const functionCommands = {
       return;
     }
 
-    for (const functionConfig of functions) {
+    for (const functionConfig of functions) {
       if (!functionConfig) {
         MessageFormatter.error("Invalid function configuration", undefined, { prefix: "Functions" });
         return;
       }
 
-      // Ensure functions array exists
-      if (!(cli as any).controller.config.functions) {
-        (cli as any).controller.config.functions = [];
-      }
+      // Resolve effective config for this function (prefer per-function choice if both sources exist)
+      const byIdOrName = (arr: any[]) => arr.find((f:any) => f?.$id === functionConfig.$id || f?.name === functionConfig.name);
+      const centralDef = byIdOrName(central as any[]);
+      const discoveredDef = byIdOrName(discovered as any[]);
+
+      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 as any).controller.config.functions) {
+        (cli as any).controller.config.functions = [];
+      }
 
-      const functionNameLower = functionConfig.name
-        .toLowerCase()
-        .replace(/\s+/g, "-");
+      const functionNameLower = effectiveConfig.name
+        .toLowerCase()
+        .replace(/\s+/g, "-");
 
       // Debug logging
       MessageFormatter.info(`🔍 Function deployment debug:`, { prefix: "Functions" });
-      MessageFormatter.info(`  Function name: ${functionConfig.name}`, { prefix: "Functions" });
-      MessageFormatter.info(`  Function ID: ${functionConfig.$id}`, { prefix: "Functions" });
-      MessageFormatter.info(`  Config dirPath: ${functionConfig.dirPath || 'undefined'}`, { prefix: "Functions" });
-      if (functionConfig.dirPath) {
-        const expandedPath = functionConfig.dirPath.startsWith('~/')
-          ? functionConfig.dirPath.replace('~', os.homedir())
-          : functionConfig.dirPath;
-        MessageFormatter.info(`  Expanded dirPath: ${expandedPath}`, { 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 as any).controller.getAppwriteFolderPath()}`, { prefix: "Functions" });
       MessageFormatter.info(`  Current working dir: ${process.cwd()}`, { prefix: "Functions" });
 
@@ -218,10 +223,10 @@ export const functionCommands = {
       // Check locations in priority order:
       const priorityLocations = [
         // 1. Config dirPath if specified (with tilde expansion)
-        functionConfig.dirPath
-          ? (require('node:path').isAbsolute(expandTildePath(functionConfig.dirPath))
-              ? expandTildePath(functionConfig.dirPath)
-              : require('node:path').resolve(yamlBaseDir, expandTildePath(functionConfig.dirPath)))
+        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(
@@ -240,7 +245,7 @@ export const functionCommands = {
         MessageFormatter.info(`  ${i + 1}. ${loc}`, { prefix: "Functions" });
       });
 
-      let functionPath: string | null = null;
+      let functionPath: string | null = null;
 
       // Check each priority location
       for (const location of priorityLocations) {
@@ -280,21 +285,21 @@ export const functionCommands = {
             const { path: downloadedPath, function: remoteFunction } =
               await downloadLatestFunctionDeployment(
                 (cli as any).controller.appwriteServer!,
-                functionConfig.$id,
-                join((cli as any).controller.getAppwriteFolderPath()!, "functions")
-              );
+                effectiveConfig.$id,
+                join((cli as any).controller.getAppwriteFolderPath()!, "functions")
+              );
             MessageFormatter.success(`✨ Function downloaded to ${downloadedPath}`, { prefix: "Functions" });
 
             functionPath = downloadedPath;
-            functionConfig.dirPath = downloadedPath;
+            effectiveConfig.dirPath = downloadedPath;
 
             const existingIndex = (cli as any).controller.config.functions.findIndex(
               (f: any) => f?.$id === remoteFunction.$id
             );
 
             if (existingIndex >= 0) {
-              (cli as any).controller.config.functions[existingIndex].dirPath =
-                downloadedPath;
+              (cli as any).controller.config.functions[existingIndex].dirPath =
+                downloadedPath;
             }
 
             await (cli as any).reloadConfigWithSessionPreservation();
@@ -303,9 +308,9 @@ export const functionCommands = {
             return;
           }
         } else {
-          MessageFormatter.error(`Function ${functionConfig.name} not found locally. Cannot deploy.`, undefined, { prefix: "Functions" });
-          return;
-        }
+          MessageFormatter.error(`Function ${effectiveConfig.name} not found locally. Cannot deploy.`, undefined, { prefix: "Functions" });
+          return;
+        }
       }
 
       if (!(cli as any).controller.appwriteServer) {
@@ -316,13 +321,13 @@ export const functionCommands = {
       try {
         await deployLocalFunction(
           (cli as any).controller.appwriteServer,
-          functionConfig.name,
-          {
-            ...functionConfig,
-            dirPath: functionPath,
-          },
-          functionPath
-        );
+          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" });

package/src/collections/attributes.ts

@@ -1835,7 +1835,7 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (
   // Filter to only attributes that need processing (new, changed, or not yet processed)
   const attributesToProcess = attributes.filter((attribute) => {
     // Skip if already processed in this session
-    if (isAttributeProcessed(currentCollection.$id, attribute.key)) {
+    if (isAttributeProcessed(dbId, currentCollection.$id, attribute.key)) {
       return false;
     }
 
@@ -1879,7 +1879,7 @@ export const createUpdateCollectionAttributesWithStatusCheck = async (
 
       if (success) {
         // Mark this specific attribute as processed
-        markAttributeProcessed(currentCollection.$id, attribute.key);
+        markAttributeProcessed(dbId, currentCollection.$id, attribute.key);
 
         // Get updated collection data for next iteration
         try {

package/src/collections/methods.ts

@@ -215,7 +215,7 @@ export const createOrUpdateCollectionsViaAdapter = async (
 ): Promise<void> => {
   const collectionsToProcess =
     selectedCollections.length > 0 ? selectedCollections : (config.collections || []);
-  if (!collectionsToProcess || collectionsToProcess.length === 0) return;
+  if (!collectionsToProcess || collectionsToProcess.length === 0) return;
 
   const usedIds = new Set<string>();
   MessageFormatter.info(`Processing ${collectionsToProcess.length} tables via adapter with intelligent state management`, { prefix: "Tables" });
@@ -238,11 +238,11 @@ export const createOrUpdateCollectionsViaAdapter = async (
   for (const collection of collectionsToProcess) {
     const { attributes, indexes, ...collectionData } = collection as any;
 
-    // Check if this table has already been processed in this session
-    if (collectionData.$id && isCollectionProcessed(collectionData.$id)) {
-      MessageFormatter.info(`Table '${collectionData.name}' already processed, skipping`, { prefix: "Tables" });
-      continue;
-    }
+    // Check if this table has already been processed in this session (per database)
+    if (collectionData.$id && isCollectionProcessed(collectionData.$id, databaseId)) {
+      MessageFormatter.info(`Table '${collectionData.name}' already processed, skipping`, { prefix: "Tables" });
+      continue;
+    }
 
     // Prepare permissions as strings (reuse Permission helper)
     const permissions: string[] = [];
@@ -649,8 +649,8 @@ export const createOrUpdateCollectionsViaAdapter = async (
       MessageFormatter.warning(`Could not evaluate deletions: ${(e as Error)?.message || e}`, { prefix: 'Attributes' });
     }
 
-    // Mark this table as fully processed to prevent re-processing
-    markCollectionProcessed(tableId, collectionData.name);
+    // Mark this table as fully processed for this database to prevent re-processing in the same DB only
+    markCollectionProcessed(tableId, collectionData.name, databaseId);
   }
 
   // Process queued relationships once mapping likely populated

package/src/interactiveCLI.ts

@@ -74,8 +74,9 @@ enum CHOICES {
 }
 
 export class InteractiveCLI {
-  private controller: UtilsController | undefined;
-  private isUsingTypeScriptConfig: boolean = false;
+  private controller: UtilsController | undefined;
+  private isUsingTypeScriptConfig: boolean = false;
+  private lastSelectedCollectionIds: string[] = [];
 
   constructor(private currentDir: string) {}
 
@@ -454,14 +455,14 @@ export class InteractiveCLI {
   /**
    * Enhanced collection/table selection with better guidance for mixed scenarios
    */
-  private async selectCollectionsAndTables(
-    database: Models.Database,
-    databasesClient: Databases,
-    message: string,
-    multiSelect = true,
-    preferLocal = false,
-    shouldFilterByDatabase = false
-  ): Promise<Models.Collection[]> {
+  private async selectCollectionsAndTables(
+    database: Models.Database,
+    databasesClient: Databases,
+    message: string,
+    multiSelect = true,
+    preferLocal = false,
+    shouldFilterByDatabase = false
+  ): Promise<Models.Collection[]> {
     const configCollections = this.getLocalCollections();
     const collectionsCount = configCollections.filter(c => !c._isFromTablesDir).length;
     const tablesCount = configCollections.filter(c => c._isFromTablesDir).length;
@@ -481,28 +482,48 @@ export class InteractiveCLI {
     // Show current database context clearly before view mode selection
     MessageFormatter.info(`DB: ${database.name}`, { prefix: "Collections" });
 
-    // Ask user if they want to filter by database or show all
+    // Ask user if they want to filter by database, show all, or reuse previous selection
+    const choices: { name: string; value: string }[] = [
+      {
+        name: `Show all available collections/tables (${totalCount} total) - You can push any collection to any database`,
+        value: "all"
+      },
+      {
+        name: `Filter by database "${database.name}" - Show only related collections/tables`,
+        value: "filter"
+      }
+    ];
+    if (this.lastSelectedCollectionIds && this.lastSelectedCollectionIds.length > 0) {
+      choices.unshift({
+        name: `Use same selection as before (${this.lastSelectedCollectionIds.length} items)`,
+        value: "same"
+      });
+    }
+
     const { filterChoice } = await inquirer.prompt([
       {
         type: "list",
         name: "filterChoice",
         message: chalk.blue("How would you like to view collections/tables?"),
-        choices: [
-          {
-            name: `Show all available collections/tables (${totalCount} total) - You can push any collection to any database`,
-            value: "all"
-          },
-          {
-            name: `Filter by database "${database.name}" - Show only related collections/tables`,
-            value: "filter"
-          }
-        ],
-        default: "all"
-      }
-    ]);
-
-    // User's choice overrides the parameter
-    const userWantsFiltering = filterChoice === "filter";
+        choices,
+        default: choices[0]?.value || "all"
+      }
+    ]);
+
+    // If user wants to reuse the previous selection, map IDs to current config and return
+    if (filterChoice === "same") {
+      const map = new Map<string, Models.Collection>(
+        this.getLocalCollections().map((c: any) => [c.$id || c.id, c as Models.Collection])
+      );
+      const selected = this.lastSelectedCollectionIds
+        .map((id) => map.get(id))
+        .filter((c): c is Models.Collection => !!c);
+      MessageFormatter.info(`Using same selection as previous: ${selected.length} item(s)`, { prefix: "Collections" });
+      return selected;
+    }
+
+    // User's choice overrides the parameter
+    const userWantsFiltering = filterChoice === "filter";
 
     // Show appropriate informational message
     if (userWantsFiltering) {
@@ -519,8 +540,18 @@ export class InteractiveCLI {
       MessageFormatter.info(`ℹ️  Showing all available collections/tables - you can push any collection to any database\n`, { prefix: "Collections" });
     }
 
-    return this.selectCollections(database, databasesClient, message, multiSelect, preferLocal, userWantsFiltering);
-  }
+    const result = await this.selectCollections(
+      database,
+      databasesClient,
+      message,
+      multiSelect,
+      preferLocal,
+      userWantsFiltering
+    );
+    // Remember this selection for subsequent databases
+    this.lastSelectedCollectionIds = (result || []).map((c: any) => c.$id || c.id);
+    return result;
+  }
 
   private getTemplateDefaults(template: string) {
     const defaults = {

package/src/main.ts

@@ -1398,6 +1398,7 @@ async function main() {
       // Build DatabaseSelection[] with tableIds per DB
       const databaseSelections: DatabaseSelection[] = [];
       const allConfigItems = controller.config.collections || controller.config.tables || [];
+      let lastSelectedTableIds: string[] | null = null;
 
       for (const dbId of selectedDbIds) {
         const db = availableDatabases.find(d => d.$id === dbId);
@@ -1418,18 +1419,54 @@ async function main() {
         // Determine selected table IDs
         let selectedTableIds: string[] = [];
         if (parsedArgv.collectionIds) {
-          const ids = parsedArgv.collectionIds.split(/[,\s]+/).filter(Boolean);
-          // Only allow IDs that are in eligible config items
-          const eligibleIds = new Set(eligibleConfigItems.map((c: any) => c.$id || c.id));
-          selectedTableIds = ids.filter(id => eligibleIds.has(id));
+          // Non-interactive: respect provided table IDs as-is (apply to each selected DB)
+          selectedTableIds = parsedArgv.collectionIds.split(/[\,\s]+/).filter(Boolean);
         } else {
-          selectedTableIds = await SelectionDialogs.selectTablesForDatabase(
-            dbId,
-            db.name,
-            availableTables,
-            eligibleConfigItems,
-            { showSelectAll: false, allowNewOnly: true, defaultSelected: [] }
-          );
+          // If we have a previous selection, offer to reuse it
+          if (lastSelectedTableIds && lastSelectedTableIds.length > 0) {
+            const inquirer = (await import("inquirer")).default;
+            const { reuseMode } = await inquirer.prompt([
+              {
+                type: "list",
+                name: "reuseMode",
+                message: `How do you want to select tables for ${db.name}?`,
+                choices: [
+                  { name: `Use same selection as previous (${lastSelectedTableIds.length} items)`, value: "same" },
+                  { name: `Filter by this database (manual select)`, value: "filter" },
+                  { name: `Show all available in this database (manual select)`, value: "all" }
+                ],
+                default: "same"
+              }
+            ]);
+
+            if (reuseMode === "same") {
+              selectedTableIds = [...lastSelectedTableIds];
+            } else if (reuseMode === "all") {
+              selectedTableIds = await SelectionDialogs.selectTablesForDatabase(
+                dbId,
+                db.name,
+                availableTables,
+                allConfigItems as any[],
+                { showSelectAll: false, allowNewOnly: false, defaultSelected: lastSelectedTableIds }
+              );
+            } else {
+              selectedTableIds = await SelectionDialogs.selectTablesForDatabase(
+                dbId,
+                db.name,
+                availableTables,
+                eligibleConfigItems,
+                { showSelectAll: false, allowNewOnly: true, defaultSelected: lastSelectedTableIds }
+              );
+            }
+          } else {
+            selectedTableIds = await SelectionDialogs.selectTablesForDatabase(
+              dbId,
+              db.name,
+              availableTables,
+              eligibleConfigItems,
+              { showSelectAll: false, allowNewOnly: true, defaultSelected: [] }
+            );
+          }
         }
 
         databaseSelections.push({
@@ -1439,6 +1476,9 @@ async function main() {
           tableNames: [],
           isNew: false,
         });
+        if (!parsedArgv.collectionIds) {
+          lastSelectedTableIds = selectedTableIds;
+        }
       }
 
       if (databaseSelections.every(sel => sel.tableIds.length === 0)) {
@@ -1451,10 +1491,13 @@ async function main() {
         collections: databaseSelections.reduce((sum, s) => sum + s.tableIds.length, 0),
         details: databaseSelections.map(s => `${s.databaseId}: ${s.tableIds.length} items`),
       };
-      const confirmed = await ConfirmationDialogs.showOperationSummary('Push', pushSummary, { confirmationRequired: true });
-      if (!confirmed) {
-        MessageFormatter.info("Push operation cancelled", { prefix: "Push" });
-        return;
+      // Skip confirmation if both dbIds and collectionIds are provided (non-interactive)
+      if (!(parsedArgv.dbIds && parsedArgv.collectionIds)) {
+        const confirmed = await ConfirmationDialogs.showOperationSummary('Push', pushSummary, { confirmationRequired: true });
+        if (!confirmed) {
+          MessageFormatter.info("Push operation cancelled", { prefix: "Push" });
+          return;
+        }
       }
 
       await controller.selectivePush(databaseSelections, []);

package/src/migrations/appwriteToX.ts

@@ -28,7 +28,7 @@ import {
 import { getDatabaseFromConfig } from "./afterImportActions.js";
 import { getAdapterFromConfig } from "../utils/getClientFromConfig.js";
 import { listBuckets } from "../storage/methods.js";
-import { listFunctions, listFunctionDeployments } from "../functions/methods.js";
+import { listFunctions, listFunctionDeployments, getFunction } from "../functions/methods.js";
 import { MessageFormatter } from "../shared/messageFormatter.js";
 import { isLegacyDatabases } from "../utils/typeGuards.js";
 import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
@@ -570,27 +570,39 @@ export class AppwriteToX {
       antivirus: bucket.antivirus,
     }));
 
-    const remoteFunctions = await listFunctions(this.config.appwriteClient!, [
-      Query.limit(1000),
-    ]);
-
-    this.updatedConfig.functions = remoteFunctions.functions.map(
-      (func) => ({
-        $id: func.$id,
-        name: func.name,
-        runtime: func.runtime as Runtime,
-        execute: func.execute,
-        events: func.events || [],
-        schedule: func.schedule || "",
-        timeout: func.timeout || 15,
-        enabled: func.enabled !== false,
-        logging: func.logging !== false,
-        entrypoint: func.entrypoint || "src/index.ts",
-        commands: func.commands || "npm install",
-        dirPath: `functions/${func.name}`,
-        specification: func.specification as Specification,
-      })
-    );
+    const remoteFunctions = await listFunctions(this.config.appwriteClient!, [
+      Query.limit(1000),
+    ]);
+
+    // Fetch full details per function to ensure 'scopes' and other fields are present
+    const detailedFunctions: any[] = [];
+    for (const f of remoteFunctions.functions) {
+      try {
+        const full = await getFunction(this.config.appwriteClient!, f.$id);
+        detailedFunctions.push(full);
+      } catch {
+        detailedFunctions.push(f);
+      }
+    }
+
+    this.updatedConfig.functions = detailedFunctions.map(
+      (func: any) => ({
+        $id: func.$id,
+        name: func.name,
+        runtime: func.runtime as Runtime,
+        execute: func.execute,
+        events: func.events || [],
+        schedule: func.schedule || "",
+        timeout: func.timeout || 15,
+        enabled: func.enabled !== false,
+        logging: func.logging !== false,
+        entrypoint: func.entrypoint || "src/index.ts",
+        commands: func.commands || "npm install",
+        scopes: Array.isArray(func.scopes) ? func.scopes : [],
+        dirPath: `functions/${func.name}`,
+        specification: func.specification as Specification,
+      })
+    );
 
     // Make sure to update the config with all changes including databases
     updatedConfig.functions = this.updatedConfig.functions;

package/src/shared/operationQueue.ts

@@ -16,10 +16,17 @@ export interface QueuedOperation {
 }
 
 // Global state management
-export const queuedOperations: QueuedOperation[] = [];
-export const nameToIdMapping: Map<string, string> = new Map();
-export const processedCollections: Set<string> = new Set();
-export const processedAttributes: Set<string> = new Set(); // format: "collectionId:attributeKey"
+export const queuedOperations: QueuedOperation[] = [];
+export const nameToIdMapping: Map<string, string> = new Map();
+// Keys are scoped per database to avoid cross-database collisions
+// Collections key format: `${databaseId}::${collectionId}`
+// Attributes key format: `${databaseId}::${collectionId}::${attributeKey}`
+export const processedCollections: Set<string> = new Set();
+export const processedAttributes: Set<string> = new Set();
+
+// Helpers to build scoped keys
+const collectionKey = (databaseId: string, collectionId: string) => `${databaseId}::${collectionId}`;
+const attributeKeyScoped = (databaseId: string, collectionId: string, key: string) => `${databaseId}::${collectionId}::${key}`;
 
 export const enqueueOperation = (operation: QueuedOperation) => {
   // Avoid duplicate queue entries for same attribute
@@ -86,52 +93,54 @@ export const clearProcessingState = () => {
 /**
  * Check if a collection has already been fully processed
  */
-export const isCollectionProcessed = (collectionId: string): boolean => {
-  return processedCollections.has(collectionId);
-};
+export const isCollectionProcessed = (collectionId: string, databaseId: string): boolean => {
+  return processedCollections.has(collectionKey(databaseId, collectionId));
+};
 
 /**
  * Mark a collection as fully processed
  */
-export const markCollectionProcessed = (collectionId: string, collectionName?: string) => {
-  processedCollections.add(collectionId);
-
-  const logData = {
-    collectionId,
-    collectionName,
-    totalProcessedCollections: processedCollections.size,
-    operation: 'markCollectionProcessed'
-  };
-
-  if (collectionName) {
-    MessageFormatter.success(`Marked collection '${collectionName}' (${collectionId}) as processed`);
-  }
-
-  logger.info('Collection marked as processed', logData);
-};
+export const markCollectionProcessed = (collectionId: string, collectionName: string | undefined, databaseId: string) => {
+  processedCollections.add(collectionKey(databaseId, collectionId));
+
+  const logData = {
+    databaseId,
+    collectionId,
+    collectionName,
+    totalProcessedCollections: processedCollections.size,
+    operation: 'markCollectionProcessed'
+  };
+
+  if (collectionName) {
+    MessageFormatter.success(`Marked collection '${collectionName}' (${collectionId}) as processed`, { prefix: 'Tables' });
+  }
+
+  logger.info('Collection marked as processed', logData);
+};
 
 /**
  * Check if a specific attribute has been processed
  */
-export const isAttributeProcessed = (collectionId: string, attributeKey: string): boolean => {
-  return processedAttributes.has(`${collectionId}:${attributeKey}`);
-};
+export const isAttributeProcessed = (databaseId: string, collectionId: string, attributeKey: string): boolean => {
+  return processedAttributes.has(attributeKeyScoped(databaseId, collectionId, attributeKey));
+};
 
 /**
  * Mark a specific attribute as processed
  */
-export const markAttributeProcessed = (collectionId: string, attributeKey: string) => {
-  const identifier = `${collectionId}:${attributeKey}`;
-  processedAttributes.add(identifier);
-
-  logger.debug('Attribute marked as processed', {
-    collectionId,
-    attributeKey,
-    identifier,
-    totalProcessedAttributes: processedAttributes.size,
-    operation: 'markAttributeProcessed'
-  });
-};
+export const markAttributeProcessed = (databaseId: string, collectionId: string, attributeKey: string) => {
+  const identifier = attributeKeyScoped(databaseId, collectionId, attributeKey);
+  processedAttributes.add(identifier);
+
+  logger.debug('Attribute marked as processed', {
+    databaseId,
+    collectionId,
+    attributeKey,
+    identifier,
+    totalProcessedAttributes: processedAttributes.size,
+    operation: 'markAttributeProcessed'
+  });
+};
 
 /**
  * Process only specific attributes in the queue, not entire collections
@@ -193,8 +202,8 @@ export const processQueue = async (db: Databases | DatabaseAdapter, dbId: string
       const attributeKey = operation.attribute.key;
       const collectionId = operation.collectionId;
 
-      // Skip if this specific attribute was already processed
-      if (isAttributeProcessed(collectionId, attributeKey)) {
+      // Skip if this specific attribute was already processed (per database)
+      if (isAttributeProcessed(dbId, collectionId, attributeKey)) {
         MessageFormatter.debug(`Attribute '${attributeKey}' already processed, removing from queue`);
         logger.debug('Removing already processed attribute from queue', {
           attributeKey,
@@ -327,7 +336,7 @@ export const processQueue = async (db: Databases | DatabaseAdapter, dbId: string
             targetCollectionName: targetCollection.name,
             operation: 'processQueue'
           });
-          markAttributeProcessed(collectionId, attributeKey);
+          markAttributeProcessed(dbId, collectionId, attributeKey);
           queuedOperations.splice(i, 1);
           progress = true;
         } else {

package/src/utilsController.ts

@@ -615,9 +615,9 @@ export class UtilsController {
     deletedCollections?: { collectionId: string; collectionName: string }[],
     collections: Models.Collection[] = []
   ) {
-    await this.init();
-    if (!this.database || !this.config)
-      throw new Error("Database or config not initialized");
+    await this.init();
+    if (!this.database || !this.config)
+      throw new Error("Database or config not initialized");
 
     // Ensure apiMode is properly set from adapter
     if (this.adapter && (!this.config.apiMode || this.config.apiMode === 'auto')) {
@@ -625,6 +625,13 @@ export class UtilsController {
       logger.debug(`Updated config.apiMode from adapter: ${this.config.apiMode}`, { prefix: "UtilsController" });
     }
 
+    // Ensure we don't carry state between databases in a multi-db push
+    // This resets processed sets and name->id mapping per database
+    try {
+      const { clearProcessingState } = await import('./shared/operationQueue.js');
+      clearProcessingState();
+    } catch {}
+
     // Always prefer adapter path for unified behavior. LegacyAdapter internally translates when needed.
     if (this.adapter) {
       logger.debug("Using adapter for createOrUpdateCollections (unified path)", {