appwrite-utils-cli 1.7.8 → 1.7.9

package/dist/functions/templates/typescript-node/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "allowJs": true,
+    "checkJs": false,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "noImplicitThis": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "moduleDetection": "force",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": false,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/dist/functions/templates/uv/README.md

@@ -0,0 +1,31 @@
+# Python UV Function Template
+
+This is a Python template for Appwrite Functions using UV for fast dependency management.
+
+## Structure
+- `src/index.py`: Main function entry point
+- `pyproject.toml`: UV/PyPI project configuration and dependencies
+
+## Usage
+Your function will receive a context object with:
+- `req`: Request object containing request data, headers, and environment variables
+- `res`: Response object for sending responses
+- `log`: Function for logging (shows in your function logs)
+- `error`: Function for error logging
+
+## Example Request
+```json
+{
+  "key": "value"
+}
+```
+
+## Development
+1. Install UV: `curl -LsSf https://astral.sh/uv/install.sh | sh`
+2. Install dependencies: `uv sync`
+3. Run locally: `uv run python src/index.py`
+4. Deploy: Dependencies will be installed during deployment
+
+## Deployment
+Make sure it's inside `appwriteConfig.yaml` functions array, and if you want to install dependencies FIRST, before Appwrite (using your system), you can
+add the `predeployCommands` to the function in `appwriteConfig.yaml`.

package/dist/functions/templates/uv/pyproject.toml

@@ -0,0 +1,30 @@
+[project]
+name = "{{functionName}}"
+version = "0.1.0"
+description = "Appwrite Python function using UV"
+authors = [{name = "Your Name", email = "you@example.com"}]
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "appwrite>=7.0.1",
+    "pydantic>=2.0.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.uv]
+dev-dependencies = [
+    "pytest>=7.0.0",
+    "black>=23.0.0",
+    "ruff>=0.1.0",
+]
+
+[tool.ruff]
+line-length = 88
+target-version = "py39"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I"]
+ignore = ["E501"]

package/dist/functions/templates/uv/src/context.py

@@ -0,0 +1,125 @@
+from collections.abc import Callable
+from typing import Any, Literal, Protocol
+
+from pydantic import BaseModel, Field
+
+
+class AppwriteHeaders(BaseModel):
+    """Appwrite request headers"""
+
+    x_appwrite_trigger: Literal["http", "schedule", "event"] | None = Field(
+        None, alias="x-appwrite-trigger"
+    )
+    x_appwrite_event: str | None = Field(None, alias="x-appwrite-event")
+    x_appwrite_key: str | None = Field(None, alias="x-appwrite-key")
+    x_appwrite_user_id: str | None = Field(None, alias="x-appwrite-user-id")
+    x_appwrite_user_jwt: str | None = Field(None, alias="x-appwrite-user-jwt")
+    x_appwrite_country_code: str | None = Field(None, alias="x-appwrite-country-code")
+    x_appwrite_continent_code: str | None = Field(
+        None, alias="x-appwrite-continent-code"
+    )
+    x_appwrite_continent_eu: str | None = Field(None, alias="x-appwrite-continent-eu")
+
+    # Allow additional headers
+    model_config = {"extra": "allow", "populate_by_name": True}
+
+
+class AppwriteEnv(BaseModel):
+    """Appwrite environment variables"""
+
+    APPWRITE_FUNCTION_API_ENDPOINT: str
+    APPWRITE_VERSION: str
+    APPWRITE_REGION: str
+    APPWRITE_FUNCTION_API_KEY: str | None = None
+    APPWRITE_FUNCTION_ID: str
+    APPWRITE_FUNCTION_NAME: str
+    APPWRITE_FUNCTION_DEPLOYMENT: str
+    APPWRITE_FUNCTION_PROJECT_ID: str
+    APPWRITE_FUNCTION_RUNTIME_NAME: str
+    APPWRITE_FUNCTION_RUNTIME_VERSION: str
+
+
+class AppwriteRequest(Protocol):
+    """Appwrite function request object with proper callable typing"""
+
+    bodyText: str | None
+    bodyJson: dict[str, Any] | str | None
+    body: Any
+    headers: dict[str, str]
+    scheme: Literal["http", "https"] | None
+    method: Literal["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"]
+    url: str | None
+    host: str | None
+    port: int | str | None
+    path: str | None
+    queryString: str | None
+    query: dict[str, str | list[str]] | None
+    variables: dict[str, str] | None
+    payload: str | None
+
+    async def text(self) -> str: ...
+
+
+class AppwriteResponse(Protocol):
+    """Appwrite function response object with proper callable typing"""
+
+    def json(
+        self,
+        data: Any,
+        status: int | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> None: ...
+
+    def text(
+        self,
+        body: str,
+        status: int | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> None: ...
+
+    def empty(self) -> None: ...
+
+    def binary(self, data: bytes) -> None: ...
+
+    def redirect(self, url: str, status: int | None = None) -> None: ...
+
+
+class AppwriteContext(Protocol):
+    """Complete Appwrite function context with proper typing"""
+
+    req: AppwriteRequest
+    res: AppwriteResponse
+
+    def log(self, message: str) -> None: ...
+
+    def error(self, message: str) -> None: ...
+
+
+# Alternative: BaseModel version for cases where you need Pydantic features
+# but want proper typing hints
+
+
+class AppwriteRequestModel(BaseModel):
+    """Pydantic model for request validation (if needed)"""
+
+    bodyText: str | None = None
+    bodyJson: dict[str, Any] | str | None = None
+    body: Any = None
+    headers: dict[str, str] = Field(default_factory=dict)
+    scheme: Literal["http", "https"] | None = None
+    method: Literal["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"]
+    url: str | None = None
+    host: str | None = None
+    port: int | str | None = None
+    path: str | None = None
+    queryString: str | None = None
+    query: dict[str, str | list[str]] | None = None
+    variables: dict[str, str] | None = None
+    payload: str | None = None
+
+    model_config = {"arbitrary_types_allowed": True}
+
+
+# Type alias for the log/error functions
+LogFunction = Callable[[str], None]
+ErrorFunction = Callable[[str], None]

package/dist/functions/templates/uv/src/index.py

@@ -0,0 +1,46 @@
+import os
+from appwrite.client import Client
+from context import AppwriteContext, AppwriteHeaders, AppwriteRequestModel
+
+def main(context: AppwriteContext):
+    req = context.req
+    res = context.res
+    log = context.log
+    error = context.error
+
+    # Optional: Validate request headers using Pydantic
+    try:
+        headers = AppwriteHeaders.model_validate(req.headers)
+        log("Headers validation successful")
+    except Exception as validation_error:
+        error(f"Headers validation failed: {validation_error}")
+
+    # Optional: Validate full request using Pydantic model
+    try:
+        request_model = AppwriteRequestModel.model_validate({
+            'method': req.method,
+            'headers': req.headers,
+            'path': req.path,
+            'url': req.url,
+            'body': req.body,
+            'bodyText': req.bodyText,
+            'bodyJson': req.bodyJson
+        })
+        log("Request validation successful")
+    except Exception as validation_error:
+        error(f"Request validation failed: {validation_error}")
+
+    client = Client()
+    client.set_endpoint(os.getenv('APPWRITE_FUNCTION_ENDPOINT'))
+    client.set_project(os.getenv('APPWRITE_FUNCTION_PROJECT_ID'))
+    client.set_key(os.getenv('APPWRITE_FUNCTION_API_KEY'))
+
+    log(f"Processing {req.method} request to {req.path}")
+
+    return res.json({
+        'message': 'Hello from Python function!',
+        'functionName': '{{functionName}}',
+        'method': req.method,
+        'path': req.path,
+        'headers': req.headers
+    })

package/dist/main.js

@@ -76,13 +76,13 @@ async function performEnhancedSync(controller, parsedArgv) {
                     isNew: false
                 }));
                 const selectionSummary = SelectionDialogs.createSyncSelectionSummary(databaseSelections, bucketSelections);
-                const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary);
+                const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary, 'pull');
                 if (!confirmed) {
-                    MessageFormatter.info("Sync operation cancelled by user", { prefix: "Sync" });
+                    MessageFormatter.info("Pull operation cancelled by user", { prefix: "Sync" });
                     return null;
                 }
-                // Perform sync with existing configuration
-                await controller.selectiveSync(databaseSelections, bucketSelections);
+                // Perform sync with existing configuration (pull from remote)
+                await controller.selectivePull(databaseSelections, bucketSelections);
                 return selectionSummary;
             }
         }
@@ -154,13 +154,13 @@ async function performEnhancedSync(controller, parsedArgv) {
         configuredBuckets, availableDatabases);
         // Show final confirmation
         const selectionSummary = SelectionDialogs.createSyncSelectionSummary(databaseSelections, bucketSelections);
-        const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary);
+        const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary, 'pull');
         if (!confirmed) {
-            MessageFormatter.info("Sync operation cancelled by user", { prefix: "Sync" });
+            MessageFormatter.info("Pull operation cancelled by user", { prefix: "Sync" });
             return null;
         }
-        // Perform the selective sync
-        await controller.selectiveSync(databaseSelections, bucketSelections);
+        // Perform the selective sync (pull from remote)
+        await controller.selectivePull(databaseSelections, bucketSelections);
         MessageFormatter.success("Enhanced sync completed successfully", { prefix: "Sync" });
         return selectionSummary;
     }

package/dist/shared/selectionDialogs.d.ts

@@ -182,7 +182,7 @@ export declare class SelectionDialogs {
     /**
      * Shows final confirmation dialog with sync selection summary
      */
-    static confirmSyncSelection(selectionSummary: SyncSelectionSummary): Promise<boolean>;
+    static confirmSyncSelection(selectionSummary: SyncSelectionSummary, operationType?: 'push' | 'pull' | 'sync'): Promise<boolean>;
     /**
      * Creates a sync selection summary from selected items
      */

package/dist/shared/selectionDialogs.js

@@ -359,8 +359,32 @@ export class SelectionDialogs {
     /**
      * Shows final confirmation dialog with sync selection summary
      */
-    static async confirmSyncSelection(selectionSummary) {
-        MessageFormatter.banner("Sync Selection Summary", "Review your selections before proceeding");
+    static async confirmSyncSelection(selectionSummary, operationType = 'sync') {
+        const labels = {
+            push: {
+                banner: "Push Selection Summary",
+                subtitle: "Review selections before pushing to Appwrite",
+                confirm: "Proceed with push operation?",
+                success: "Push operation confirmed.",
+                cancel: "Push operation cancelled."
+            },
+            pull: {
+                banner: "Pull Selection Summary",
+                subtitle: "Review selections before pulling from Appwrite",
+                confirm: "Proceed with pull operation?",
+                success: "Pull operation confirmed.",
+                cancel: "Pull operation cancelled."
+            },
+            sync: {
+                banner: "Sync Selection Summary",
+                subtitle: "Review your selections before proceeding",
+                confirm: "Proceed with sync operation?",
+                success: "Sync operation confirmed.",
+                cancel: "Sync operation cancelled."
+            }
+        };
+        const label = labels[operationType];
+        MessageFormatter.banner(label.banner, label.subtitle);
         // Database summary
         console.log(chalk.bold.cyan("\n📊 Databases:"));
         console.log(`  Total: ${selectionSummary.totalDatabases}`);
@@ -395,20 +419,20 @@ export class SelectionDialogs {
         const { confirmed } = await inquirer.prompt([{
                 type: 'confirm',
                 name: 'confirmed',
-                message: chalk.green.bold('Proceed with sync operation?'),
+                message: chalk.green.bold(label.confirm),
                 default: true
             }]);
         if (confirmed) {
-            MessageFormatter.success("Sync operation confirmed.", { skipLogging: true });
-            logger.info("Sync selection confirmed", {
+            MessageFormatter.success(label.success, { skipLogging: true });
+            logger.info(`${operationType} selection confirmed`, {
                 databases: selectionSummary.totalDatabases,
                 tables: selectionSummary.totalTables,
                 buckets: selectionSummary.totalBuckets
             });
         }
         else {
-            MessageFormatter.warning("Sync operation cancelled.", { skipLogging: true });
-            logger.info("Sync selection cancelled by user");
+            MessageFormatter.warning(label.cancel, { skipLogging: true });
+            logger.info(`${operationType} selection cancelled by user`);
         }
         return confirmed;
     }

package/dist/utilsController.d.ts

@@ -83,7 +83,8 @@ export declare class UtilsController {
     generateSchemas(): Promise<void>;
     importData(options?: SetupOptions): Promise<void>;
     synchronizeConfigurations(databases?: Models.Database[], config?: AppwriteConfig, databaseSelections?: DatabaseSelection[], bucketSelections?: BucketSelection[]): Promise<void>;
-    selectiveSync(databaseSelections: DatabaseSelection[], bucketSelections: BucketSelection[]): Promise<void>;
+    selectivePull(databaseSelections: DatabaseSelection[], bucketSelections: BucketSelection[]): Promise<void>;
+    selectivePush(databaseSelections: DatabaseSelection[], bucketSelections: BucketSelection[]): Promise<void>;
     syncDb(databases?: Models.Database[], collections?: Models.Collection[]): Promise<void>;
     getAppwriteFolderPath(): string | undefined;
     transferData(options: TransferOptions): Promise<void>;

package/dist/utilsController.js

@@ -1,6 +1,7 @@
 import { Client, Databases, Query, Storage, Users, } from "node-appwrite";
 import {} from "appwrite-utils";
-import { loadConfig, loadConfigWithPath, findAppwriteConfig, findFunctionsDir, } from "./utils/loadConfigs.js";
+import { findAppwriteConfig, findFunctionsDir, } from "./utils/loadConfigs.js";
+import { normalizeFunctionName, validateFunctionDirectory } from './functions/pathResolution.js';
 import { UsersController } from "./users/methods.js";
 import { AppwriteToX } from "./migrations/appwriteToX.js";
 import { ImportController } from "./migrations/importController.js";
@@ -39,6 +40,26 @@ export class UtilsController {
      * Get the UtilsController singleton instance
      */
     static getInstance(currentUserDir, directConfig) {
+        // Clear instance if currentUserDir has changed
+        if (UtilsController.instance &&
+            UtilsController.instance.currentUserDir !== currentUserDir) {
+            logger.debug(`Clearing singleton: currentUserDir changed from ${UtilsController.instance.currentUserDir} to ${currentUserDir}`, { prefix: "UtilsController" });
+            UtilsController.clearInstance();
+        }
+        // Clear instance if directConfig endpoint or project has changed
+        if (UtilsController.instance && directConfig) {
+            const existingConfig = UtilsController.instance.config;
+            if (existingConfig) {
+                const endpointChanged = directConfig.appwriteEndpoint &&
+                    existingConfig.appwriteEndpoint !== directConfig.appwriteEndpoint;
+                const projectChanged = directConfig.appwriteProject &&
+                    existingConfig.appwriteProject !== directConfig.appwriteProject;
+                if (endpointChanged || projectChanged) {
+                    logger.debug("Clearing singleton: endpoint or project changed", { prefix: "UtilsController" });
+                    UtilsController.clearInstance();
+                }
+            }
+        }
         if (!UtilsController.instance) {
             UtilsController.instance = new UtilsController(currentUserDir, directConfig);
         }
@@ -295,9 +316,14 @@ export class UtilsController {
         for (const entry of entries) {
             if (entry.isDirectory()) {
                 const functionPath = path.join(functionsDir, entry.name);
-                // Match with config functions by name
+                // Validate it's a function directory
+                if (!validateFunctionDirectory(functionPath)) {
+                    continue; // Skip invalid directories
+                }
+                // Match with config functions using normalized names
                 if (this.config?.functions) {
-                    const matchingFunc = this.config.functions.find((f) => f.name.toLowerCase() === entry.name.toLowerCase());
+                    const normalizedEntryName = normalizeFunctionName(entry.name);
+                    const matchingFunc = this.config.functions.find((f) => normalizeFunctionName(f.name) === normalizedEntryName);
                     if (matchingFunc) {
                         functionDirMap.set(matchingFunc.name, functionPath);
                     }
@@ -422,20 +448,22 @@ export class UtilsController {
     async generateSchemas() {
         // Schema generation doesn't need Appwrite connection, just config
         if (!this.config) {
-            if (this.appwriteFolderPath && this.appwriteConfigPath) {
-                MessageFormatter.progress("Loading config from file...", { prefix: "Config" });
-                try {
-                    const { config, actualConfigPath } = await loadConfigWithPath(this.appwriteFolderPath, { validate: false, strictMode: false, reportValidation: false });
-                    this.config = config;
-                    MessageFormatter.info(`Loaded config from: ${actualConfigPath}`, { prefix: "Config" });
-                }
-                catch (error) {
-                    MessageFormatter.error("Failed to load config from file", error instanceof Error ? error : undefined, { prefix: "Config" });
-                    return;
+            MessageFormatter.progress("Loading config from ConfigManager...", { prefix: "Config" });
+            try {
+                const configManager = ConfigManager.getInstance();
+                // Load config if not already loaded
+                if (!configManager.hasConfig()) {
+                    await configManager.loadConfig({
+                        configDir: this.currentUserDir,
+                        validate: false,
+                        strictMode: false,
+                    });
                 }
+                this.config = configManager.getConfig();
+                MessageFormatter.info("Config loaded successfully from ConfigManager", { prefix: "Config" });
             }
-            else {
-                MessageFormatter.error("No configuration available", undefined, { prefix: "Controller" });
+            catch (error) {
+                MessageFormatter.error("Failed to load config", error instanceof Error ? error : undefined, { prefix: "Config" });
                 return;
             }
         }
@@ -521,13 +549,13 @@ export class UtilsController {
             logger.warn("Schema regeneration failed during sync:", error);
         }
     }
-    async selectiveSync(databaseSelections, bucketSelections) {
+    async selectivePull(databaseSelections, bucketSelections) {
         await this.init();
         if (!this.database) {
             MessageFormatter.error("Database not initialized", undefined, { prefix: "Controller" });
             return;
         }
-        MessageFormatter.progress("Starting selective sync...", { prefix: "Controller" });
+        MessageFormatter.progress("Starting selective pull (Appwrite → local config)...", { prefix: "Controller" });
         // Convert database selections to Models.Database format
         const selectedDatabases = [];
         for (const dbSelection of databaseSelections) {
@@ -547,7 +575,7 @@ export class UtilsController {
             }
         }
         if (selectedDatabases.length === 0) {
-            MessageFormatter.warning("No valid databases selected for sync", { prefix: "Controller" });
+            MessageFormatter.warning("No valid databases selected for pull", { prefix: "Controller" });
             return;
         }
         // Log bucket selections if provided
@@ -560,7 +588,71 @@ export class UtilsController {
         }
         // Perform selective sync using the enhanced synchronizeConfigurations method
         await this.synchronizeConfigurations(selectedDatabases, this.config, databaseSelections, bucketSelections);
-        MessageFormatter.success("Selective sync completed successfully!", { prefix: "Controller" });
+        MessageFormatter.success("Selective pull completed successfully! Remote config pulled to local.", { prefix: "Controller" });
+    }
+    async selectivePush(databaseSelections, bucketSelections) {
+        await this.init();
+        if (!this.database) {
+            MessageFormatter.error("Database not initialized", undefined, { prefix: "Controller" });
+            return;
+        }
+        MessageFormatter.progress("Starting selective push (local config → Appwrite)...", { prefix: "Controller" });
+        // Convert database selections to Models.Database format
+        const selectedDatabases = [];
+        for (const dbSelection of databaseSelections) {
+            // Get the full database object from the controller
+            const databases = await fetchAllDatabases(this.database);
+            const database = databases.find(db => db.$id === dbSelection.databaseId);
+            if (database) {
+                selectedDatabases.push(database);
+                MessageFormatter.info(`Selected database: ${database.name} (${database.$id})`, { prefix: "Controller" });
+                // Log selected tables for this database
+                if (dbSelection.tableIds && dbSelection.tableIds.length > 0) {
+                    MessageFormatter.info(`  Tables: ${dbSelection.tableIds.join(', ')}`, { prefix: "Controller" });
+                }
+            }
+            else {
+                MessageFormatter.warning(`Database with ID ${dbSelection.databaseId} not found`, { prefix: "Controller" });
+            }
+        }
+        if (selectedDatabases.length === 0) {
+            MessageFormatter.warning("No valid databases selected for push", { prefix: "Controller" });
+            return;
+        }
+        // Log bucket selections if provided
+        if (bucketSelections && bucketSelections.length > 0) {
+            MessageFormatter.info(`Selected ${bucketSelections.length} buckets:`, { prefix: "Controller" });
+            for (const bucketSelection of bucketSelections) {
+                const dbInfo = bucketSelection.databaseId ? ` (DB: ${bucketSelection.databaseId})` : '';
+                MessageFormatter.info(`  - ${bucketSelection.bucketName} (${bucketSelection.bucketId})${dbInfo}`, { prefix: "Controller" });
+            }
+        }
+        // PUSH OPERATION: Push local configuration to Appwrite
+        // Build selected collections/tables from databaseSelections
+        const selectedCollections = [];
+        // Get all collections/tables from config (they're at the root level, not nested in databases)
+        const allCollections = this.config?.collections || this.config?.tables || [];
+        // Collect all selected table IDs from all database selections
+        const selectedTableIds = new Set();
+        for (const dbSelection of databaseSelections) {
+            for (const tableId of dbSelection.tableIds) {
+                selectedTableIds.add(tableId);
+            }
+        }
+        // Filter to only the selected table IDs
+        for (const collection of allCollections) {
+            const collectionId = collection.$id || collection.id;
+            if (selectedTableIds.has(collectionId)) {
+                selectedCollections.push(collection);
+            }
+        }
+        MessageFormatter.info(`Pushing ${selectedCollections.length} selected tables/collections to Appwrite`, { prefix: "Controller" });
+        // Ensure databases exist
+        await this.ensureDatabasesExist(selectedDatabases);
+        await this.ensureDatabaseConfigBucketsExist(selectedDatabases);
+        // Create/update ONLY the selected collections/tables
+        await this.createOrUpdateCollectionsForDatabases(selectedDatabases, selectedCollections);
+        MessageFormatter.success("Selective push completed successfully! Local config pushed to Appwrite.", { prefix: "Controller" });
     }
     async syncDb(databases = [], collections = []) {
         await this.init();

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.7.8",
+  "version": "1.7.9",
   "main": "src/main.ts",
   "type": "module",
   "repository": {
@@ -24,7 +24,9 @@
     "appwrite-migrate": "./dist/main.js"
   },
   "scripts": {
-    "build": "bun run tsc",
+    "build": "bun run tsc && bun run copy-templates",
+    "prebuild": "rm -rf dist",
+    "copy-templates": "tsx scripts/copy-templates.ts",
     "start": "tsx --no-cache src/main.ts",
     "deploy": "bun run build && npm publish --access public",
     "test": "jest",

package/scripts/copy-templates.ts

@@ -0,0 +1,23 @@
+import { cpSync, mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+const src = join(process.cwd(), 'src', 'functions', 'templates');
+const dest = join(process.cwd(), 'dist', 'functions', 'templates');
+
+// Verify source exists
+if (!existsSync(src)) {
+  console.error('❌ Error: Template source directory not found:', src);
+  process.exit(1);
+}
+
+// Create destination directory
+mkdirSync(dest, { recursive: true });
+
+// Copy templates recursively
+try {
+  cpSync(src, dest, { recursive: true });
+  console.log('✓ Templates copied to dist/functions/templates/');
+} catch (error) {
+  console.error('❌ Failed to copy templates:', error);
+  process.exit(1);
+}

package/src/cli/commands/databaseCommands.ts

@@ -26,14 +26,13 @@ export const databaseCommands = {
       // Get local collections for selection
       const localCollections = (cli as any).getLocalCollections();
 
-      // Prompt about existing configuration
-      const { syncExisting, modifyConfiguration } = await SelectionDialogs.promptForExistingConfig(configuredDatabases);
+      // Push operations always use local configuration as source of truth
 
       // Select databases
       const selectedDatabaseIds = await SelectionDialogs.selectDatabases(
         availableDatabases,
         configuredDatabases,
-        { showSelectAll: true, allowNewOnly: !syncExisting }
+        { showSelectAll: true, allowNewOnly: false }
       );
 
       if (selectedDatabaseIds.length === 0) {
@@ -133,16 +132,16 @@ export const databaseCommands = {
         bucketSelections
       );
 
-      const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary);
+      const confirmed = await SelectionDialogs.confirmSyncSelection(selectionSummary, 'push');
 
       if (!confirmed) {
-        MessageFormatter.info("Sync operation cancelled by user", { prefix: "Database" });
+        MessageFormatter.info("Push operation cancelled by user", { prefix: "Database" });
         return;
       }
 
-      // Perform selective sync using the controller
-      MessageFormatter.progress("Starting selective sync...", { prefix: "Database" });
-      await (cli as any).controller!.selectiveSync(databaseSelections, bucketSelections);
+      // Perform selective push using the controller
+      MessageFormatter.progress("Starting selective push...", { prefix: "Database" });
+      await (cli as any).controller!.selectivePush(databaseSelections, bucketSelections);
 
       MessageFormatter.success("\n✅ All database configurations pushed successfully!", { prefix: "Database" });