appwrite-utils-cli 0.9.999 → 0.10.1

package/README.md

@@ -147,6 +147,9 @@ This updated CLI ensures that developers have robust tools at their fingertips t
 
 ## Changelog
 
+- 0.10.01: Fixed `predeployCommands` to work
+- 0.10.001: Updated `deployFunction` to not updateConfig if it's already present
+- 0.10.0: Fixed `synchronize configurations` for functions, now you do not need to deploy the function first
 - 0.9.999: Fixed Functions, looks for `./functions` in addition to `appwriteConfigFolder/functions`
 - 0.9.998: Fixed transfer finally, added `--targetDbId` and `--sourceDbId` as aliases
 - 0.9.994: Added function deployment management, in BETA, and fixed document transfer between databases

package/dist/functions/deployments.js

@@ -3,6 +3,7 @@ import { InputFile } from "node-appwrite/file";
 import { create as createTarball } from "tar";
 import { join } from "node:path";
 import fs from "node:fs";
+import { platform } from "node:os";
 import {} from "appwrite-utils";
 import chalk from "chalk";
 import cliProgress from "cli-progress";
@@ -46,20 +47,20 @@ export const deployFunction = async (client, functionId, codePath, activate = tr
     const fileObject = InputFile.fromBuffer(new Uint8Array(fileBuffer), `function-${functionId}.tar.gz`);
     try {
         console.log(chalk.blue("🚀 Creating deployment..."));
+        progressBar.start(1, 0);
         const functionResponse = await functions.createDeployment(functionId, fileObject, activate, entrypoint, commands, (progress) => {
             const chunks = progress.chunksUploaded;
             const total = progress.chunksTotal;
-            if (chunks && total) {
-                if (chunks === 0) {
+            if (chunks !== undefined && total) {
+                if (chunks === 0 && total !== 0) {
                     progressBar.start(total, 0);
                 }
-                else if (chunks === total) {
-                    progressBar.update(total);
-                    progressBar.stop();
-                    console.log(chalk.green("✅ Upload complete!"));
-                }
                 else {
                     progressBar.update(chunks);
+                    if (chunks === total) {
+                        progressBar.stop();
+                        console.log(chalk.green("✅ Upload complete!"));
+                    }
                 }
             }
         });
@@ -85,22 +86,29 @@ export const deployLocalFunction = async (client, functionName, functionConfig,
         functionConfig.dirPath ||
         findFunctionDirectory(process.cwd(), functionName) ||
         join(process.cwd(), "functions", functionName.toLowerCase().replace(/\s+/g, "-"));
+    if (!fs.existsSync(resolvedPath)) {
+        throw new Error(`Function directory not found at ${resolvedPath}`);
+    }
     if (functionConfig.predeployCommands?.length) {
         console.log(chalk.blue("Executing predeploy commands..."));
+        const isWindows = platform() === "win32";
         for (const command of functionConfig.predeployCommands) {
             try {
                 console.log(chalk.gray(`Executing: ${command}`));
                 execSync(command, {
                     cwd: resolvedPath,
                     stdio: "inherit",
+                    shell: isWindows ? "cmd.exe" : "/bin/sh",
+                    windowsHide: true,
                 });
             }
             catch (error) {
-                console.error(chalk.red(`Failed to execute predeploy command: ${command}`));
-                throw error;
+                console.error(chalk.red(`Failed to execute predeploy command: ${command}`), error);
+                throw new Error(``);
             }
         }
     }
+    // Only create function if it doesn't exist
     if (!functionExists) {
         await createFunction(client, functionConfig.$id, functionConfig.name, functionConfig.runtime, functionConfig.execute, functionConfig.events, functionConfig.schedule, functionConfig.timeout, functionConfig.enabled, functionConfig.logging, functionConfig.entrypoint, functionConfig.commands);
     }

package/dist/interactiveCLI.js

@@ -10,7 +10,7 @@ import { AppwriteFunctionSchema, parseAttribute, PermissionToAppwritePermission,
 import { ulid } from "ulidx";
 import chalk from "chalk";
 import { DateTime } from "luxon";
-import { createFunctionTemplate, deleteFunction, downloadLatestFunctionDeployment, listFunctions, listSpecifications, } from "./functions/methods.js";
+import { createFunctionTemplate, deleteFunction, downloadLatestFunctionDeployment, getFunction, listFunctions, listSpecifications, } from "./functions/methods.js";
 import { deployLocalFunction } from "./functions/deployments.js";
 import { join } from "node:path";
 import fs from "node:fs";
@@ -298,7 +298,17 @@ export class InteractiveCLI {
             join(process.cwd(), functionName), // ./functionName
             join(basePath, "functions", functionName), // appwriteFolder/functions/functionName
             join(basePath, functionName), // appwriteFolder/functionName
+            join(basePath, functionName.toLowerCase()), // appwriteFolder/functionName.toLowerCase()
+            join(basePath, functionName.toLowerCase().replace(/\s+/g, "")), // appwriteFolder/functionName.toLowerCase().replace(/\s+/g, "")
+            join(process.cwd(), functionName.toLowerCase()), // ./functionName.toLowerCase()
         ];
+        // Create different variations of the function name for comparison
+        const functionNameVariations = new Set([
+            functionName.toLowerCase(),
+            functionName.toLowerCase().replace(/\s+/g, ""),
+            functionName.toLowerCase().replace(/[^a-z0-9]/g, ""),
+            functionName.toLowerCase().replace(/[-_\s]+/g, ""),
+        ]);
         // Check common locations first
         for (const path of commonPaths) {
             try {
@@ -331,7 +341,15 @@ export class InteractiveCLI {
                     if (entry.isDirectory() &&
                         !entry.name.startsWith(".") &&
                         entry.name !== "node_modules") {
-                        if (entry.name === functionName) {
+                        const entryNameVariations = new Set([
+                            entry.name.toLowerCase(),
+                            entry.name.toLowerCase().replace(/\s+/g, ""),
+                            entry.name.toLowerCase().replace(/[^a-z0-9]/g, ""),
+                            entry.name.toLowerCase().replace(/[-_\s]+/g, ""),
+                        ]);
+                        // Check if any variation of the entry name matches any variation of the function name
+                        const hasMatch = [...functionNameVariations].some((fnVar) => [...entryNameVariations].includes(fnVar));
+                        if (hasMatch) {
                             console.log(chalk.green(`Found function at: ${fullPath}`));
                             return fullPath;
                         }
@@ -361,23 +379,26 @@ export class InteractiveCLI {
             console.log(chalk.red("Invalid function configuration"));
             return;
         }
+        // Ensure functions array exists
+        if (!this.controller.config.functions) {
+            this.controller.config.functions = [];
+        }
         let functionPath = join(this.controller.getAppwriteFolderPath(), "functions", functionConfig.name);
         if (!fs.existsSync(functionPath)) {
             console.log(chalk.yellow(`Function not found in primary location, searching subdirectories...`));
-            const foundPath = await this.findFunctionInSubdirectories(this.controller.getAppwriteFolderPath(), functionConfig.name);
+            const foundPath = await this.findFunctionInSubdirectories(this.controller.getAppwriteFolderPath(), functionConfig.name.toLowerCase());
             if (foundPath) {
                 console.log(chalk.green(`Found function at: ${foundPath}`));
                 functionPath = foundPath;
                 functionConfig.dirPath = foundPath;
             }
             else {
-                console.log(chalk.yellow(`Function ${functionConfig.name} not found locally in any subdirectory`));
                 const { shouldDownload } = await inquirer.prompt([
                     {
                         type: "confirm",
                         name: "shouldDownload",
-                        message: "Would you like to download the latest deployment?",
-                        default: true,
+                        message: "Function not found locally. Would you like to download the latest deployment?",
+                        default: false,
                     },
                 ]);
                 if (shouldDownload) {
@@ -385,42 +406,15 @@ export class InteractiveCLI {
                         console.log(chalk.blue("Downloading latest deployment..."));
                         const { path: downloadedPath, function: remoteFunction } = await downloadLatestFunctionDeployment(this.controller.appwriteServer, functionConfig.$id, join(this.controller.getAppwriteFolderPath(), "functions"));
                         console.log(chalk.green(`✨ Function downloaded to ${downloadedPath}`));
-                        // Update the config and functions array safely
-                        this.controller.config.functions =
-                            this.controller.config.functions || [];
-                        const newFunction = {
-                            $id: remoteFunction.$id,
-                            name: remoteFunction.name,
-                            runtime: remoteFunction.runtime,
-                            execute: remoteFunction.execute || [],
-                            events: remoteFunction.events || [],
-                            schedule: remoteFunction.schedule || "",
-                            timeout: remoteFunction.timeout || 15,
-                            enabled: remoteFunction.enabled !== false,
-                            logging: remoteFunction.logging !== false,
-                            entrypoint: remoteFunction.entrypoint || "src/index.ts",
-                            commands: remoteFunction.commands || "npm install",
-                            dirPath: downloadedPath,
-                            scopes: (remoteFunction.scopes || []),
-                            installationId: remoteFunction.installationId,
-                            providerRepositoryId: remoteFunction.providerRepositoryId,
-                            providerBranch: remoteFunction.providerBranch,
-                            providerSilentMode: remoteFunction.providerSilentMode,
-                            providerRootDirectory: remoteFunction.providerRootDirectory,
-                            specification: remoteFunction.specification,
-                        };
                         const existingIndex = this.controller.config.functions.findIndex((f) => f?.$id === remoteFunction.$id);
                         if (existingIndex >= 0) {
-                            this.controller.config.functions[existingIndex] = newFunction;
-                        }
-                        else {
-                            this.controller.config.functions.push(newFunction);
+                            // Only update the dirPath if function exists
+                            this.controller.config.functions[existingIndex].dirPath =
+                                downloadedPath;
                         }
-                        const schemaGenerator = new SchemaGenerator(this.controller.config, this.controller.getAppwriteFolderPath());
-                        schemaGenerator.updateConfig(this.controller.config);
-                        console.log(chalk.green("✨ Updated appwriteConfig.ts with new function"));
                         await this.controller.reloadConfig();
                         functionConfig.dirPath = downloadedPath;
+                        functionPath = downloadedPath;
                     }
                     catch (error) {
                         console.error(chalk.red("Failed to download function deployment:"), error);
@@ -428,7 +422,7 @@ export class InteractiveCLI {
                     }
                 }
                 else {
-                    console.log(chalk.yellow("Deployment cancelled"));
+                    console.log(chalk.red(`Function ${functionConfig.name} not found locally. Cannot deploy.`));
                     return;
                 }
             }
@@ -437,7 +431,13 @@ export class InteractiveCLI {
             console.log(chalk.red("Appwrite server not initialized"));
             return;
         }
-        await deployLocalFunction(this.controller.appwriteServer, functionConfig.name, functionConfig);
+        try {
+            await deployLocalFunction(this.controller.appwriteServer, functionConfig.name, functionConfig);
+            console.log(chalk.green("✨ Function deployed successfully!"));
+        }
+        catch (error) {
+            console.error(chalk.red("Failed to deploy function:"), error);
+        }
     }
     async deleteFunction() {
         const functions = await this.selectFunctions("Select functions to delete:", true, false);
@@ -455,52 +455,33 @@ export class InteractiveCLI {
             }
         }
     }
-    async selectFunctions(message, multiSelect = true, preferLocal = false) {
-        await this.initControllerIfNeeded();
-        const configFunctions = this.getLocalFunctions();
-        let remoteFunctions = [];
-        try {
-            const functions = await this.controller.listAllFunctions();
-            remoteFunctions = functions;
-        }
-        catch (error) {
-            console.log(chalk.yellow(`Note: Remote functions not available, using only local functions`));
-        }
-        // Combine functions based on whether we're deploying or not
-        const allFunctions = preferLocal
-            ? [
-                ...configFunctions,
-                ...remoteFunctions.map((f) => AppwriteFunctionSchema.parse(f)),
-            ]
-            : [
-                ...remoteFunctions.map((f) => AppwriteFunctionSchema.parse(f)),
-                ...configFunctions.filter((f) => !remoteFunctions.some((rf) => rf.name === f.name)),
-            ];
-        if (allFunctions.length === 0) {
-            console.log(chalk.red("No functions available"));
-            return [];
-        }
-        const choices = allFunctions
-            .sort((a, b) => a.name.localeCompare(b.name))
-            .map((func) => ({
-            name: func.name,
-            value: func,
-        }));
+    async selectFunctions(message, multiple = true, includeRemote = false) {
+        const remoteFunctions = includeRemote
+            ? await listFunctions(this.controller.appwriteServer, [
+                Query.limit(1000),
+            ])
+            : { functions: [] };
+        const localFunctions = this.getLocalFunctions();
+        // Combine functions, preferring local ones
+        const allFunctions = [
+            ...localFunctions,
+            ...remoteFunctions.functions.filter((rf) => !localFunctions.some((lf) => lf.name === rf.name)),
+        ];
         const { selectedFunctions } = await inquirer.prompt([
             {
-                type: multiSelect ? "checkbox" : "list",
+                type: multiple ? "checkbox" : "list",
                 name: "selectedFunctions",
-                message: chalk.blue(message),
-                choices,
+                message,
+                choices: allFunctions.map((f) => ({
+                    name: `${f.name} (${f.$id})${localFunctions.some((lf) => lf.name === f.name)
+                        ? " (Local)"
+                        : " (Remote)"}`,
+                    value: f,
+                })),
                 loop: true,
-                pageSize: 10,
             },
         ]);
-        // For single selection, ensure we return an array
-        if (!multiSelect) {
-            return selectedFunctions ? [selectedFunctions] : [];
-        }
-        return selectedFunctions || [];
+        return multiple ? selectedFunctions : [selectedFunctions];
     }
     getLocalFunctions() {
         const configFunctions = this.controller.config?.functions || [];
@@ -805,55 +786,153 @@ export class InteractiveCLI {
                 const hasLocal = localFunctions.some((lf) => lf.$id === func.$id);
                 const hasRemote = remoteFunctions.some((rf) => rf.$id === func.$id);
                 if (hasLocal && hasRemote) {
+                    // First try to find the function locally
+                    let functionPath = join(this.controller.getAppwriteFolderPath(), "functions", func.name);
+                    if (!fs.existsSync(functionPath)) {
+                        console.log(chalk.yellow(`Function not found in primary location, searching subdirectories...`));
+                        const foundPath = await this.findFunctionInSubdirectories(this.controller.getAppwriteFolderPath(), func.name);
+                        if (foundPath) {
+                            console.log(chalk.green(`Found function at: ${foundPath}`));
+                            functionPath = foundPath;
+                        }
+                    }
                     const { preference } = await inquirer.prompt([
                         {
                             type: "list",
                             name: "preference",
-                            message: `Function "${func.name}" exists both locally and remotely. What would you like to do?`,
+                            message: `Function "${func.name}" ${functionPath ? "found at " + functionPath : "not found locally"}. What would you like to do?`,
                             choices: [
-                                {
-                                    name: "Keep local version (deploy to remote)",
-                                    value: "local",
-                                },
+                                ...(functionPath
+                                    ? [
+                                        {
+                                            name: "Keep local version (deploy to remote)",
+                                            value: "local",
+                                        },
+                                    ]
+                                    : []),
                                 { name: "Use remote version (download)", value: "remote" },
+                                { name: "Update config only", value: "config" },
                                 { name: "Skip this function", value: "skip" },
                             ],
                         },
                     ]);
-                    if (preference === "local") {
+                    if (preference === "local" && functionPath) {
                         await this.controller.deployFunction(func.name);
                     }
                     else if (preference === "remote") {
                         await downloadLatestFunctionDeployment(this.controller.appwriteServer, func.$id, join(this.controller.getAppwriteFolderPath(), "functions"));
                     }
+                    else if (preference === "config") {
+                        const remoteFunction = await getFunction(this.controller.appwriteServer, func.$id);
+                        const newFunction = {
+                            $id: remoteFunction.$id,
+                            name: remoteFunction.name,
+                            runtime: remoteFunction.runtime,
+                            execute: remoteFunction.execute || [],
+                            events: remoteFunction.events || [],
+                            schedule: remoteFunction.schedule || "",
+                            timeout: remoteFunction.timeout || 15,
+                            enabled: remoteFunction.enabled !== false,
+                            logging: remoteFunction.logging !== false,
+                            entrypoint: remoteFunction.entrypoint || "src/index.ts",
+                            commands: remoteFunction.commands || "npm install",
+                            scopes: (remoteFunction.scopes || []),
+                            installationId: remoteFunction.installationId,
+                            providerRepositoryId: remoteFunction.providerRepositoryId,
+                            providerBranch: remoteFunction.providerBranch,
+                            providerSilentMode: remoteFunction.providerSilentMode,
+                            providerRootDirectory: remoteFunction.providerRootDirectory,
+                            specification: remoteFunction.specification,
+                        };
+                        const existingIndex = this.controller.config.functions.findIndex((f) => f.$id === remoteFunction.$id);
+                        if (existingIndex >= 0) {
+                            this.controller.config.functions[existingIndex] = newFunction;
+                        }
+                        else {
+                            this.controller.config.functions.push(newFunction);
+                        }
+                        console.log(chalk.green(`Updated config for function: ${func.name}`));
+                    }
                 }
                 else if (hasLocal) {
-                    const { deploy } = await inquirer.prompt([
+                    // Similar check for local-only functions
+                    let functionPath = join(this.controller.getAppwriteFolderPath(), "functions", func.name);
+                    if (!fs.existsSync(functionPath)) {
+                        const foundPath = await this.findFunctionInSubdirectories(this.controller.getAppwriteFolderPath(), func.name);
+                        if (foundPath) {
+                            functionPath = foundPath;
+                        }
+                    }
+                    const { action } = await inquirer.prompt([
                         {
-                            type: "confirm",
-                            name: "deploy",
-                            message: `Function "${func.name}" exists only locally. Deploy to remote?`,
-                            default: true,
+                            type: "list",
+                            name: "action",
+                            message: `Function "${func.name}" ${functionPath ? "found at " + functionPath : "not found locally"}. What would you like to do?`,
+                            choices: [
+                                ...(functionPath
+                                    ? [
+                                        {
+                                            name: "Deploy to remote",
+                                            value: "deploy",
+                                        },
+                                    ]
+                                    : []),
+                                { name: "Skip this function", value: "skip" },
+                            ],
                         },
                     ]);
-                    if (deploy) {
+                    if (action === "deploy" && functionPath) {
                         await this.controller.deployFunction(func.name);
                     }
                 }
                 else if (hasRemote) {
-                    const { download } = await inquirer.prompt([
+                    const { action } = await inquirer.prompt([
                         {
-                            type: "confirm",
-                            name: "download",
-                            message: `Function "${func.name}" exists only remotely. Download locally?`,
-                            default: true,
+                            type: "list",
+                            name: "action",
+                            message: `Function "${func.name}" exists only remotely. What would you like to do?`,
+                            choices: [
+                                { name: "Update config only", value: "config" },
+                                { name: "Download locally", value: "download" },
+                                { name: "Skip this function", value: "skip" },
+                            ],
                         },
                     ]);
-                    if (download) {
+                    if (action === "download") {
                         await downloadLatestFunctionDeployment(this.controller.appwriteServer, func.$id, join(this.controller.getAppwriteFolderPath(), "functions"));
                     }
+                    else if (action === "config") {
+                        const remoteFunction = await getFunction(this.controller.appwriteServer, func.$id);
+                        const newFunction = {
+                            $id: remoteFunction.$id,
+                            name: remoteFunction.name,
+                            runtime: remoteFunction.runtime,
+                            execute: remoteFunction.execute || [],
+                            events: remoteFunction.events || [],
+                            schedule: remoteFunction.schedule || "",
+                            timeout: remoteFunction.timeout || 15,
+                            enabled: remoteFunction.enabled !== false,
+                            logging: remoteFunction.logging !== false,
+                            entrypoint: remoteFunction.entrypoint || "src/index.ts",
+                            commands: remoteFunction.commands || "npm install",
+                            scopes: (remoteFunction.scopes || []),
+                            installationId: remoteFunction.installationId,
+                            providerRepositoryId: remoteFunction.providerRepositoryId,
+                            providerBranch: remoteFunction.providerBranch,
+                            providerSilentMode: remoteFunction.providerSilentMode,
+                            providerRootDirectory: remoteFunction.providerRootDirectory,
+                            specification: remoteFunction.specification,
+                        };
+                        this.controller.config.functions =
+                            this.controller.config.functions || [];
+                        this.controller.config.functions.push(newFunction);
+                        console.log(chalk.green(`Added config for remote function: ${func.name}`));
+                    }
                 }
             }
+            // Update schemas after all changes
+            const schemaGenerator = new SchemaGenerator(this.controller.config, this.controller.getAppwriteFolderPath());
+            schemaGenerator.updateConfig(this.controller.config);
         }
         console.log(chalk.green("✨ Configurations synchronized successfully!"));
     }

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

package/src/functions/deployments.ts

@@ -3,6 +3,7 @@ import { InputFile } from "node-appwrite/file";
 import { create as createTarball } from "tar";
 import { join } from "node:path";
 import fs from "node:fs";
+import { platform } from "node:os";
 import { type AppwriteFunction, type Specification } from "appwrite-utils";
 import chalk from "chalk";
 import cliProgress from "cli-progress";
@@ -76,6 +77,7 @@ export const deployFunction = async (
 
   try {
     console.log(chalk.blue("🚀 Creating deployment..."));
+    progressBar.start(1, 0);
     const functionResponse = await functions.createDeployment(
       functionId,
       fileObject,
@@ -85,15 +87,15 @@ export const deployFunction = async (
       (progress) => {
         const chunks = progress.chunksUploaded;
         const total = progress.chunksTotal;
-        if (chunks && total) {
-          if (chunks === 0) {
+        if (chunks !== undefined && total) {
+          if (chunks === 0 && total !== 0) {
             progressBar.start(total, 0);
-          } else if (chunks === total) {
-            progressBar.update(total);
-            progressBar.stop();
-            console.log(chalk.green("✅ Upload complete!"));
           } else {
             progressBar.update(chunks);
+            if (chunks === total) {
+              progressBar.stop();
+              console.log(chalk.green("✅ Upload complete!"));
+            }
           }
         }
       }
@@ -132,24 +134,34 @@ export const deployLocalFunction = async (
       functionName.toLowerCase().replace(/\s+/g, "-")
     );
 
+  if (!fs.existsSync(resolvedPath)) {
+    throw new Error(`Function directory not found at ${resolvedPath}`);
+  }
+
   if (functionConfig.predeployCommands?.length) {
     console.log(chalk.blue("Executing predeploy commands..."));
+    const isWindows = platform() === "win32";
+
     for (const command of functionConfig.predeployCommands) {
       try {
         console.log(chalk.gray(`Executing: ${command}`));
         execSync(command, {
           cwd: resolvedPath,
           stdio: "inherit",
+          shell: isWindows ? "cmd.exe" : "/bin/sh",
+          windowsHide: true,
         });
       } catch (error) {
         console.error(
-          chalk.red(`Failed to execute predeploy command: ${command}`)
+          chalk.red(`Failed to execute predeploy command: ${command}`),
+          error
         );
-        throw error;
+        throw new Error(``);
       }
     }
   }
 
+  // Only create function if it doesn't exist
   if (!functionExists) {
     await createFunction(
       client,

package/src/interactiveCLI.ts

@@ -35,6 +35,7 @@ import {
   createFunctionTemplate,
   deleteFunction,
   downloadLatestFunctionDeployment,
+  getFunction,
   listFunctions,
   listSpecifications,
 } from "./functions/methods.js";
@@ -397,8 +398,19 @@ export class InteractiveCLI {
       join(process.cwd(), functionName), // ./functionName
       join(basePath, "functions", functionName), // appwriteFolder/functions/functionName
       join(basePath, functionName), // appwriteFolder/functionName
+      join(basePath, functionName.toLowerCase()), // appwriteFolder/functionName.toLowerCase()
+      join(basePath, functionName.toLowerCase().replace(/\s+/g, "")), // appwriteFolder/functionName.toLowerCase().replace(/\s+/g, "")
+      join(process.cwd(), functionName.toLowerCase()), // ./functionName.toLowerCase()
     ];
 
+    // Create different variations of the function name for comparison
+    const functionNameVariations = new Set([
+      functionName.toLowerCase(),
+      functionName.toLowerCase().replace(/\s+/g, ""),
+      functionName.toLowerCase().replace(/[^a-z0-9]/g, ""),
+      functionName.toLowerCase().replace(/[-_\s]+/g, ""),
+    ]);
+
     // Check common locations first
     for (const path of commonPaths) {
       try {
@@ -444,7 +456,19 @@ export class InteractiveCLI {
             !entry.name.startsWith(".") &&
             entry.name !== "node_modules"
           ) {
-            if (entry.name === functionName) {
+            const entryNameVariations = new Set([
+              entry.name.toLowerCase(),
+              entry.name.toLowerCase().replace(/\s+/g, ""),
+              entry.name.toLowerCase().replace(/[^a-z0-9]/g, ""),
+              entry.name.toLowerCase().replace(/[-_\s]+/g, ""),
+            ]);
+
+            // Check if any variation of the entry name matches any variation of the function name
+            const hasMatch = [...functionNameVariations].some((fnVar) =>
+              [...entryNameVariations].includes(fnVar)
+            );
+
+            if (hasMatch) {
               console.log(chalk.green(`Found function at: ${fullPath}`));
               return fullPath;
             }
@@ -486,6 +510,11 @@ export class InteractiveCLI {
       return;
     }
 
+    // Ensure functions array exists
+    if (!this.controller.config.functions) {
+      this.controller.config.functions = [];
+    }
+
     let functionPath = join(
       this.controller.getAppwriteFolderPath(),
       "functions",
@@ -500,7 +529,7 @@ export class InteractiveCLI {
       );
       const foundPath = await this.findFunctionInSubdirectories(
         this.controller.getAppwriteFolderPath(),
-        functionConfig.name
+        functionConfig.name.toLowerCase()
       );
 
       if (foundPath) {
@@ -508,18 +537,13 @@ export class InteractiveCLI {
         functionPath = foundPath;
         functionConfig.dirPath = foundPath;
       } else {
-        console.log(
-          chalk.yellow(
-            `Function ${functionConfig.name} not found locally in any subdirectory`
-          )
-        );
-
         const { shouldDownload } = await inquirer.prompt([
           {
             type: "confirm",
             name: "shouldDownload",
-            message: "Would you like to download the latest deployment?",
-            default: true,
+            message:
+              "Function not found locally. Would you like to download the latest deployment?",
+            default: false,
           },
         ]);
 
@@ -536,53 +560,19 @@ export class InteractiveCLI {
               chalk.green(`✨ Function downloaded to ${downloadedPath}`)
             );
 
-            // Update the config and functions array safely
-            this.controller.config.functions =
-              this.controller.config.functions || [];
-
-            const newFunction = {
-              $id: remoteFunction.$id,
-              name: remoteFunction.name,
-              runtime: remoteFunction.runtime as Runtime,
-              execute: remoteFunction.execute || [],
-              events: remoteFunction.events || [],
-              schedule: remoteFunction.schedule || "",
-              timeout: remoteFunction.timeout || 15,
-              enabled: remoteFunction.enabled !== false,
-              logging: remoteFunction.logging !== false,
-              entrypoint: remoteFunction.entrypoint || "src/index.ts",
-              commands: remoteFunction.commands || "npm install",
-              dirPath: downloadedPath,
-              scopes: (remoteFunction.scopes || []) as FunctionScope[],
-              installationId: remoteFunction.installationId,
-              providerRepositoryId: remoteFunction.providerRepositoryId,
-              providerBranch: remoteFunction.providerBranch,
-              providerSilentMode: remoteFunction.providerSilentMode,
-              providerRootDirectory: remoteFunction.providerRootDirectory,
-              specification: remoteFunction.specification as Specification,
-            };
-
             const existingIndex = this.controller.config.functions.findIndex(
               (f) => f?.$id === remoteFunction.$id
             );
 
             if (existingIndex >= 0) {
-              this.controller.config.functions[existingIndex] = newFunction;
-            } else {
-              this.controller.config.functions.push(newFunction);
+              // Only update the dirPath if function exists
+              this.controller.config.functions[existingIndex].dirPath =
+                downloadedPath;
             }
 
-            const schemaGenerator = new SchemaGenerator(
-              this.controller.config,
-              this.controller.getAppwriteFolderPath()
-            );
-            schemaGenerator.updateConfig(this.controller.config);
-            console.log(
-              chalk.green("✨ Updated appwriteConfig.ts with new function")
-            );
-
             await this.controller.reloadConfig();
             functionConfig.dirPath = downloadedPath;
+            functionPath = downloadedPath;
           } catch (error) {
             console.error(
               chalk.red("Failed to download function deployment:"),
@@ -591,7 +581,11 @@ export class InteractiveCLI {
             return;
           }
         } else {
-          console.log(chalk.yellow("Deployment cancelled"));
+          console.log(
+            chalk.red(
+              `Function ${functionConfig.name} not found locally. Cannot deploy.`
+            )
+          );
           return;
         }
       }
@@ -602,11 +596,16 @@ export class InteractiveCLI {
       return;
     }
 
-    await deployLocalFunction(
-      this.controller.appwriteServer,
-      functionConfig.name,
-      functionConfig
-    );
+    try {
+      await deployLocalFunction(
+        this.controller.appwriteServer,
+        functionConfig.name,
+        functionConfig
+      );
+      console.log(chalk.green("✨ Function deployed successfully!"));
+    } catch (error) {
+      console.error(chalk.red("Failed to deploy function:"), error);
+    }
   }
 
   private async deleteFunction(): Promise<void> {
@@ -638,67 +637,42 @@ export class InteractiveCLI {
 
   private async selectFunctions(
     message: string,
-    multiSelect = true,
-    preferLocal = false
+    multiple: boolean = true,
+    includeRemote: boolean = false
   ): Promise<AppwriteFunction[]> {
-    await this.initControllerIfNeeded();
-
-    const configFunctions = this.getLocalFunctions();
-    let remoteFunctions: Models.Function[] = [];
-
-    try {
-      const functions = await this.controller!.listAllFunctions();
-      remoteFunctions = functions;
-    } catch (error) {
-      console.log(
-        chalk.yellow(
-          `Note: Remote functions not available, using only local functions`
-        )
-      );
-    }
-
-    // Combine functions based on whether we're deploying or not
-    const allFunctions = preferLocal
-      ? [
-          ...configFunctions,
-          ...remoteFunctions.map((f) => AppwriteFunctionSchema.parse(f)),
-        ]
-      : [
-          ...remoteFunctions.map((f) => AppwriteFunctionSchema.parse(f)),
-          ...configFunctions.filter(
-            (f) => !remoteFunctions.some((rf) => rf.name === f.name)
-          ),
-        ];
-
-    if (allFunctions.length === 0) {
-      console.log(chalk.red("No functions available"));
-      return [];
-    }
+    const remoteFunctions = includeRemote
+      ? await listFunctions(this.controller!.appwriteServer!, [
+          Query.limit(1000),
+        ])
+      : { functions: [] };
+    const localFunctions = this.getLocalFunctions();
 
-    const choices = allFunctions
-      .sort((a, b) => a.name.localeCompare(b.name))
-      .map((func) => ({
-        name: func.name,
-        value: func,
-      }));
+    // Combine functions, preferring local ones
+    const allFunctions = [
+      ...localFunctions,
+      ...remoteFunctions.functions.filter(
+        (rf) => !localFunctions.some((lf) => lf.name === rf.name)
+      ),
+    ];
 
     const { selectedFunctions } = await inquirer.prompt([
       {
-        type: multiSelect ? "checkbox" : "list",
+        type: multiple ? "checkbox" : "list",
         name: "selectedFunctions",
-        message: chalk.blue(message),
-        choices,
+        message,
+        choices: allFunctions.map((f) => ({
+          name: `${f.name} (${f.$id})${
+            localFunctions.some((lf) => lf.name === f.name)
+              ? " (Local)"
+              : " (Remote)"
+          }`,
+          value: f,
+        })),
         loop: true,
-        pageSize: 10,
       },
     ]);
 
-    // For single selection, ensure we return an array
-    if (!multiSelect) {
-      return selectedFunctions ? [selectedFunctions] : [];
-    }
-
-    return selectedFunctions || [];
+    return multiple ? selectedFunctions : [selectedFunctions];
   }
 
   private getLocalFunctions(): AppwriteFunction[] {
@@ -1102,23 +1076,54 @@ export class InteractiveCLI {
         const hasRemote = remoteFunctions.some((rf) => rf.$id === func.$id);
 
         if (hasLocal && hasRemote) {
+          // First try to find the function locally
+          let functionPath = join(
+            this.controller!.getAppwriteFolderPath(),
+            "functions",
+            func.name
+          );
+
+          if (!fs.existsSync(functionPath)) {
+            console.log(
+              chalk.yellow(
+                `Function not found in primary location, searching subdirectories...`
+              )
+            );
+            const foundPath = await this.findFunctionInSubdirectories(
+              this.controller!.getAppwriteFolderPath(),
+              func.name
+            );
+
+            if (foundPath) {
+              console.log(chalk.green(`Found function at: ${foundPath}`));
+              functionPath = foundPath;
+            }
+          }
+
           const { preference } = await inquirer.prompt([
             {
               type: "list",
               name: "preference",
-              message: `Function "${func.name}" exists both locally and remotely. What would you like to do?`,
+              message: `Function "${func.name}" ${
+                functionPath ? "found at " + functionPath : "not found locally"
+              }. What would you like to do?`,
               choices: [
-                {
-                  name: "Keep local version (deploy to remote)",
-                  value: "local",
-                },
+                ...(functionPath
+                  ? [
+                      {
+                        name: "Keep local version (deploy to remote)",
+                        value: "local",
+                      },
+                    ]
+                  : []),
                 { name: "Use remote version (download)", value: "remote" },
+                { name: "Update config only", value: "config" },
                 { name: "Skip this function", value: "skip" },
               ],
             },
           ]);
 
-          if (preference === "local") {
+          if (preference === "local" && functionPath) {
             await this.controller!.deployFunction(func.name);
           } else if (preference === "remote") {
             await downloadLatestFunctionDeployment(
@@ -1126,39 +1131,152 @@ export class InteractiveCLI {
               func.$id,
               join(this.controller!.getAppwriteFolderPath(), "functions")
             );
+          } else if (preference === "config") {
+            const remoteFunction = await getFunction(
+              this.controller!.appwriteServer!,
+              func.$id
+            );
+
+            const newFunction = {
+              $id: remoteFunction.$id,
+              name: remoteFunction.name,
+              runtime: remoteFunction.runtime as Runtime,
+              execute: remoteFunction.execute || [],
+              events: remoteFunction.events || [],
+              schedule: remoteFunction.schedule || "",
+              timeout: remoteFunction.timeout || 15,
+              enabled: remoteFunction.enabled !== false,
+              logging: remoteFunction.logging !== false,
+              entrypoint: remoteFunction.entrypoint || "src/index.ts",
+              commands: remoteFunction.commands || "npm install",
+              scopes: (remoteFunction.scopes || []) as FunctionScope[],
+              installationId: remoteFunction.installationId,
+              providerRepositoryId: remoteFunction.providerRepositoryId,
+              providerBranch: remoteFunction.providerBranch,
+              providerSilentMode: remoteFunction.providerSilentMode,
+              providerRootDirectory: remoteFunction.providerRootDirectory,
+              specification: remoteFunction.specification as Specification,
+            };
+
+            const existingIndex = this.controller!.config!.functions!.findIndex(
+              (f) => f.$id === remoteFunction.$id
+            );
+
+            if (existingIndex >= 0) {
+              this.controller!.config!.functions![existingIndex] = newFunction;
+            } else {
+              this.controller!.config!.functions!.push(newFunction);
+            }
+            console.log(
+              chalk.green(`Updated config for function: ${func.name}`)
+            );
           }
         } else if (hasLocal) {
-          const { deploy } = await inquirer.prompt([
+          // Similar check for local-only functions
+          let functionPath = join(
+            this.controller!.getAppwriteFolderPath(),
+            "functions",
+            func.name
+          );
+
+          if (!fs.existsSync(functionPath)) {
+            const foundPath = await this.findFunctionInSubdirectories(
+              this.controller!.getAppwriteFolderPath(),
+              func.name
+            );
+
+            if (foundPath) {
+              functionPath = foundPath;
+            }
+          }
+
+          const { action } = await inquirer.prompt([
             {
-              type: "confirm",
-              name: "deploy",
-              message: `Function "${func.name}" exists only locally. Deploy to remote?`,
-              default: true,
+              type: "list",
+              name: "action",
+              message: `Function "${func.name}" ${
+                functionPath ? "found at " + functionPath : "not found locally"
+              }. What would you like to do?`,
+              choices: [
+                ...(functionPath
+                  ? [
+                      {
+                        name: "Deploy to remote",
+                        value: "deploy",
+                      },
+                    ]
+                  : []),
+                { name: "Skip this function", value: "skip" },
+              ],
             },
           ]);
 
-          if (deploy) {
+          if (action === "deploy" && functionPath) {
             await this.controller!.deployFunction(func.name);
           }
         } else if (hasRemote) {
-          const { download } = await inquirer.prompt([
+          const { action } = await inquirer.prompt([
             {
-              type: "confirm",
-              name: "download",
-              message: `Function "${func.name}" exists only remotely. Download locally?`,
-              default: true,
+              type: "list",
+              name: "action",
+              message: `Function "${func.name}" exists only remotely. What would you like to do?`,
+              choices: [
+                { name: "Update config only", value: "config" },
+                { name: "Download locally", value: "download" },
+                { name: "Skip this function", value: "skip" },
+              ],
             },
           ]);
 
-          if (download) {
+          if (action === "download") {
             await downloadLatestFunctionDeployment(
               this.controller!.appwriteServer!,
               func.$id,
               join(this.controller!.getAppwriteFolderPath(), "functions")
             );
+          } else if (action === "config") {
+            const remoteFunction = await getFunction(
+              this.controller!.appwriteServer!,
+              func.$id
+            );
+
+            const newFunction = {
+              $id: remoteFunction.$id,
+              name: remoteFunction.name,
+              runtime: remoteFunction.runtime as Runtime,
+              execute: remoteFunction.execute || [],
+              events: remoteFunction.events || [],
+              schedule: remoteFunction.schedule || "",
+              timeout: remoteFunction.timeout || 15,
+              enabled: remoteFunction.enabled !== false,
+              logging: remoteFunction.logging !== false,
+              entrypoint: remoteFunction.entrypoint || "src/index.ts",
+              commands: remoteFunction.commands || "npm install",
+              scopes: (remoteFunction.scopes || []) as FunctionScope[],
+              installationId: remoteFunction.installationId,
+              providerRepositoryId: remoteFunction.providerRepositoryId,
+              providerBranch: remoteFunction.providerBranch,
+              providerSilentMode: remoteFunction.providerSilentMode,
+              providerRootDirectory: remoteFunction.providerRootDirectory,
+              specification: remoteFunction.specification as Specification,
+            };
+
+            this.controller!.config!.functions =
+              this.controller!.config!.functions || [];
+            this.controller!.config!.functions.push(newFunction);
+            console.log(
+              chalk.green(`Added config for remote function: ${func.name}`)
+            );
           }
         }
       }
+
+      // Update schemas after all changes
+      const schemaGenerator = new SchemaGenerator(
+        this.controller!.config!,
+        this.controller!.getAppwriteFolderPath()
+      );
+      schemaGenerator.updateConfig(this.controller!.config!);
     }
 
     console.log(chalk.green("✨ Configurations synchronized successfully!"));