appwrite-utils-cli 0.9.998 → 0.10.0

package/README.md

@@ -147,6 +147,8 @@ This updated CLI ensures that developers have robust tools at their fingertips t
 
 ## Changelog
 
+- 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
 - 0.9.993: Fixed `updateFunctionSpecifications` resetting functions to default with undefined values (oops)

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";
@@ -292,27 +292,55 @@ export class InteractiveCLI {
         console.log(chalk.green("✨ Function created successfully!"));
     }
     async findFunctionInSubdirectories(basePath, functionName) {
-        const queue = [basePath];
+        // Common locations to check first
+        const commonPaths = [
+            join(process.cwd(), "functions", functionName), // ./functions/functionName
+            join(process.cwd(), functionName), // ./functionName
+            join(basePath, "functions", functionName), // appwriteFolder/functions/functionName
+            join(basePath, functionName), // appwriteFolder/functionName
+        ];
+        // Check common locations first
+        for (const path of commonPaths) {
+            try {
+                const stats = await fs.promises.stat(path);
+                if (stats.isDirectory()) {
+                    console.log(chalk.green(`Found function at common location: ${path}`));
+                    return path;
+                }
+            }
+            catch (error) {
+                // Path doesn't exist, continue to next
+            }
+        }
+        // If not found in common locations, do recursive search
+        console.log(chalk.yellow("Function not found in common locations, searching subdirectories..."));
+        const queue = [process.cwd(), basePath];
+        const searched = new Set();
         while (queue.length > 0) {
             const currentPath = queue.shift();
+            if (searched.has(currentPath))
+                continue;
+            searched.add(currentPath);
             try {
                 const entries = await fs.promises.readdir(currentPath, {
                     withFileTypes: true,
                 });
-                // Check if function exists in current directory
-                const functionPath = join(currentPath, functionName);
-                if (fs.existsSync(functionPath)) {
-                    return functionPath;
-                }
-                // Add subdirectories to queue
                 for (const entry of entries) {
-                    if (entry.isDirectory()) {
-                        queue.push(join(currentPath, entry.name));
+                    const fullPath = join(currentPath, entry.name);
+                    // Skip node_modules and hidden directories
+                    if (entry.isDirectory() &&
+                        !entry.name.startsWith(".") &&
+                        entry.name !== "node_modules") {
+                        if (entry.name === functionName) {
+                            console.log(chalk.green(`Found function at: ${fullPath}`));
+                            return fullPath;
+                        }
+                        queue.push(fullPath);
                     }
                 }
             }
             catch (error) {
-                console.log(chalk.yellow(`Skipping inaccessible directory: ${currentPath}`));
+                console.log(chalk.yellow(`Error reading directory ${currentPath}:`, error));
             }
         }
         return null;
@@ -333,83 +361,127 @@ export class InteractiveCLI {
             console.log(chalk.red("Invalid function configuration"));
             return;
         }
-        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);
-            if (foundPath) {
-                console.log(chalk.green(`Found function at: ${foundPath}`));
-                functionPath = foundPath;
-                functionConfig.dirPath = foundPath;
+        const { shouldDownload } = await inquirer.prompt([
+            {
+                type: "confirm",
+                name: "shouldDownload",
+                message: "Would you like to download the latest deployment?",
+                default: false,
+            },
+        ]);
+        if (shouldDownload) {
+            try {
+                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);
+                }
+                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;
             }
-            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,
-                    },
-                ]);
-                if (shouldDownload) {
-                    try {
-                        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);
-                        }
-                        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;
-                    }
-                    catch (error) {
-                        console.error(chalk.red("Failed to download function deployment:"), error);
-                        return;
-                    }
+            catch (error) {
+                console.error(chalk.red("Failed to download function deployment:"), error);
+                return;
+            }
+        }
+        else {
+            console.log(chalk.yellow("Skipping download, updating config only..."));
+            try {
+                // Update the config with remote function info
+                this.controller.config.functions =
+                    this.controller.config.functions || [];
+                const remoteFunction = await getFunction(this.controller.appwriteServer, functionConfig.$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 {
-                    console.log(chalk.yellow("Deployment cancelled"));
-                    return;
+                    this.controller.config.functions.push(newFunction);
                 }
+                const schemaGenerator = new SchemaGenerator(this.controller.config, this.controller.getAppwriteFolderPath());
+                schemaGenerator.updateConfig(this.controller.config);
+                console.log(chalk.green("✨ Updated appwriteConfig.ts with function info"));
+                await this.controller.reloadConfig();
+            }
+            catch (error) {
+                console.error(chalk.red("Failed to update function config:"), error);
+                return;
             }
         }
-        if (!this.controller.appwriteServer) {
-            console.log(chalk.red("Appwrite server not initialized"));
-            return;
+        // Only try to deploy if we didn't just download
+        if (!shouldDownload) {
+            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);
+                if (foundPath) {
+                    console.log(chalk.green(`Found function at: ${foundPath}`));
+                    functionPath = foundPath;
+                    functionConfig.dirPath = foundPath;
+                }
+                else {
+                    console.log(chalk.red(`Function ${functionConfig.name} not found locally in any subdirectory. Cannot deploy.`));
+                    return;
+                }
+            }
+            if (!this.controller.appwriteServer) {
+                console.log(chalk.red("Appwrite server not initialized"));
+                return;
+            }
+            await deployLocalFunction(this.controller.appwriteServer, functionConfig.name, functionConfig);
         }
-        await deployLocalFunction(this.controller.appwriteServer, functionConfig.name, functionConfig);
     }
     async deleteFunction() {
         const functions = await this.selectFunctions("Select functions to delete:", true, false);
@@ -777,55 +849,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.998",
+  "version": "0.10.0",
   "main": "src/main.ts",
   "type": "module",
   "repository": {

package/src/interactiveCLI.ts

@@ -35,6 +35,7 @@ import {
   createFunctionTemplate,
   deleteFunction,
   downloadLatestFunctionDeployment,
+  getFunction,
   listFunctions,
   listSpecifications,
 } from "./functions/methods.js";
@@ -391,31 +392,70 @@ export class InteractiveCLI {
     basePath: string,
     functionName: string
   ): Promise<string | null> {
-    const queue = [basePath];
+    // Common locations to check first
+    const commonPaths = [
+      join(process.cwd(), "functions", functionName), // ./functions/functionName
+      join(process.cwd(), functionName), // ./functionName
+      join(basePath, "functions", functionName), // appwriteFolder/functions/functionName
+      join(basePath, functionName), // appwriteFolder/functionName
+    ];
+
+    // Check common locations first
+    for (const path of commonPaths) {
+      try {
+        const stats = await fs.promises.stat(path);
+        if (stats.isDirectory()) {
+          console.log(
+            chalk.green(`Found function at common location: ${path}`)
+          );
+          return path;
+        }
+      } catch (error) {
+        // Path doesn't exist, continue to next
+      }
+    }
+
+    // If not found in common locations, do recursive search
+    console.log(
+      chalk.yellow(
+        "Function not found in common locations, searching subdirectories..."
+      )
+    );
+
+    const queue = [process.cwd(), basePath];
+    const searched = new Set<string>();
 
     while (queue.length > 0) {
       const currentPath = queue.shift()!;
 
+      if (searched.has(currentPath)) continue;
+      searched.add(currentPath);
+
       try {
         const entries = await fs.promises.readdir(currentPath, {
           withFileTypes: true,
         });
 
-        // Check if function exists in current directory
-        const functionPath = join(currentPath, functionName);
-        if (fs.existsSync(functionPath)) {
-          return functionPath;
-        }
-
-        // Add subdirectories to queue
         for (const entry of entries) {
-          if (entry.isDirectory()) {
-            queue.push(join(currentPath, entry.name));
+          const fullPath = join(currentPath, entry.name);
+
+          // Skip node_modules and hidden directories
+          if (
+            entry.isDirectory() &&
+            !entry.name.startsWith(".") &&
+            entry.name !== "node_modules"
+          ) {
+            if (entry.name === functionName) {
+              console.log(chalk.green(`Found function at: ${fullPath}`));
+              return fullPath;
+            }
+
+            queue.push(fullPath);
           }
         }
       } catch (error) {
         console.log(
-          chalk.yellow(`Skipping inaccessible directory: ${currentPath}`)
+          chalk.yellow(`Error reading directory ${currentPath}:`, error)
         );
       }
     }
@@ -447,127 +487,183 @@ export class InteractiveCLI {
       return;
     }
 
-    let functionPath = join(
-      this.controller.getAppwriteFolderPath(),
-      "functions",
-      functionConfig.name
-    );
+    const { shouldDownload } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "shouldDownload",
+        message: "Would you like to download the latest deployment?",
+        default: false,
+      },
+    ]);
 
-    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
-      );
+    if (shouldDownload) {
+      try {
+        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 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 (foundPath) {
-        console.log(chalk.green(`Found function at: ${foundPath}`));
-        functionPath = foundPath;
-        functionConfig.dirPath = foundPath;
-      } else {
+        if (existingIndex >= 0) {
+          this.controller.config.functions[existingIndex] = newFunction;
+        } else {
+          this.controller.config.functions.push(newFunction);
+        }
+
+        const schemaGenerator = new SchemaGenerator(
+          this.controller.config,
+          this.controller.getAppwriteFolderPath()
+        );
+        schemaGenerator.updateConfig(this.controller.config);
         console.log(
-          chalk.yellow(
-            `Function ${functionConfig.name} not found locally in any subdirectory`
-          )
+          chalk.green("✨ Updated appwriteConfig.ts with new function")
         );
 
-        const { shouldDownload } = await inquirer.prompt([
-          {
-            type: "confirm",
-            name: "shouldDownload",
-            message: "Would you like to download the latest deployment?",
-            default: true,
-          },
-        ]);
+        await this.controller.reloadConfig();
+        functionConfig.dirPath = downloadedPath;
+      } catch (error) {
+        console.error(
+          chalk.red("Failed to download function deployment:"),
+          error
+        );
+        return;
+      }
+    } else {
+      console.log(chalk.yellow("Skipping download, updating config only..."));
+      try {
+        // Update the config with remote function info
+        this.controller.config.functions =
+          this.controller.config.functions || [];
 
-        if (shouldDownload) {
-          try {
-            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}`)
-            );
+        const remoteFunction = await getFunction(
+          this.controller.appwriteServer!,
+          functionConfig.$id
+        );
 
-            // 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",
+          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
+        );
 
-            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,
-            };
+        if (existingIndex >= 0) {
+          this.controller.config.functions[existingIndex] = newFunction;
+        } else {
+          this.controller.config.functions.push(newFunction);
+        }
 
-            const existingIndex = this.controller.config.functions.findIndex(
-              (f) => f?.$id === remoteFunction.$id
-            );
+        const schemaGenerator = new SchemaGenerator(
+          this.controller.config,
+          this.controller.getAppwriteFolderPath()
+        );
+        schemaGenerator.updateConfig(this.controller.config);
+        console.log(
+          chalk.green("✨ Updated appwriteConfig.ts with function info")
+        );
 
-            if (existingIndex >= 0) {
-              this.controller.config.functions[existingIndex] = newFunction;
-            } else {
-              this.controller.config.functions.push(newFunction);
-            }
+        await this.controller.reloadConfig();
+      } catch (error) {
+        console.error(chalk.red("Failed to update function config:"), error);
+        return;
+      }
+    }
 
-            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")
-            );
+    // Only try to deploy if we didn't just download
+    if (!shouldDownload) {
+      let functionPath = join(
+        this.controller.getAppwriteFolderPath(),
+        "functions",
+        functionConfig.name
+      );
 
-            await this.controller.reloadConfig();
-            functionConfig.dirPath = downloadedPath;
-          } catch (error) {
-            console.error(
-              chalk.red("Failed to download function deployment:"),
-              error
-            );
-            return;
-          }
+      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
+        );
+
+        if (foundPath) {
+          console.log(chalk.green(`Found function at: ${foundPath}`));
+          functionPath = foundPath;
+          functionConfig.dirPath = foundPath;
         } else {
-          console.log(chalk.yellow("Deployment cancelled"));
+          console.log(
+            chalk.red(
+              `Function ${functionConfig.name} not found locally in any subdirectory. Cannot deploy.`
+            )
+          );
           return;
         }
       }
-    }
 
-    if (!this.controller.appwriteServer) {
-      console.log(chalk.red("Appwrite server not initialized"));
-      return;
-    }
+      if (!this.controller.appwriteServer) {
+        console.log(chalk.red("Appwrite server not initialized"));
+        return;
+      }
 
-    await deployLocalFunction(
-      this.controller.appwriteServer,
-      functionConfig.name,
-      functionConfig
-    );
+      await deployLocalFunction(
+        this.controller.appwriteServer,
+        functionConfig.name,
+        functionConfig
+      );
+    }
   }
 
   private async deleteFunction(): Promise<void> {
@@ -1063,23 +1159,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(
@@ -1087,39 +1214,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!"));