appwrite-utils-cli 0.10.62 → 0.10.64

package/README.md

@@ -147,6 +147,8 @@ This updated CLI ensures that developers have robust tools at their fingertips t
 
 ## Changelog
 
+- 0.10.64: Fixed `Deploy Function(s)` not ignoring things properly
+- 0.10.63: My `collectLocalFunctions` function was failing to add the `scopes` and a few others to the function, accidentally, fixed now
 - 0.10.62: Made `Deploy Function(s)` also update the functions, as not all things (timeout, specification, etc.) are updated via deploy
 - 0.10.61: Fixed ignore haha, also added `ignore` to the `Functions` config, to specify what to ignore when creating the `.tar.gz` file
 - 0.10.051: Added `node_modules` and a few others to the ignore

package/dist/functions/deployments.js

@@ -33,6 +33,15 @@ export const deployFunction = async (client, functionId, codePath, activate = tr
     // Convert ignored patterns to lowercase for case-insensitive comparison
     const ignoredLower = ignored.map((pattern) => pattern.toLowerCase());
     const tarPath = join(process.cwd(), `function-${functionId}.tar.gz`);
+    // Verify codePath exists and is a directory
+    if (!fs.existsSync(codePath)) {
+        throw new Error(`Function directory not found at ${codePath}`);
+    }
+    const stats = await fs.promises.stat(codePath);
+    if (!stats.isDirectory()) {
+        throw new Error(`${codePath} is not a directory`);
+    }
+    console.log(chalk.blue(`Creating tarball from ${codePath}`));
     const progressBar = new cliProgress.SingleBar({
         format: "Uploading |" +
             chalk.cyan("{bar}") +
@@ -47,10 +56,17 @@ export const deployFunction = async (client, functionId, codePath, activate = tr
         cwd: codePath,
         filter: (path, stat) => {
             const relativePath = relative(codePath, join(codePath, path)).toLowerCase();
-            return !ignoredLower.some((pattern) => relativePath.startsWith(pattern) ||
-                relativePath.includes(`/${pattern}`));
+            // Skip if path matches any ignored pattern
+            if (ignoredLower.some((pattern) => relativePath.startsWith(pattern) ||
+                relativePath.includes(`/${pattern}`) ||
+                relativePath.includes(`\\${pattern}`))) {
+                console.log(chalk.gray(`Ignoring ${path}`));
+                return false;
+            }
+            return true;
         },
-    }, ["."]);
+    }, ["."] // This now only includes contents of codePath since we set cwd to codePath
+    );
     const fileBuffer = await fs.promises.readFile(tarPath);
     const fileObject = InputFile.fromBuffer(new Uint8Array(fileBuffer), `function-${functionId}.tar.gz`);
     try {
@@ -127,11 +143,11 @@ export const deployLocalFunction = async (client, functionName, functionConfig,
     }
     // 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, functionConfig.scopes, functionConfig.installationId, functionConfig.providerRepositoryId, functionConfig.providerBranch, functionConfig.providerSilentMode, functionConfig.providerRootDirectory, functionConfig.templateRepository, functionConfig.templateOwner, functionConfig.templateRootDirectory, functionConfig.templateVersion, functionConfig.specification);
+        await createFunction(client, functionConfig);
     }
     else {
         console.log(chalk.blue("Updating function..."));
-        await updateFunction(client, functionConfig.$id, functionConfig.name, functionConfig.runtime, functionConfig.execute, functionConfig.events, functionConfig.schedule, functionConfig.timeout, functionConfig.enabled, functionConfig.logging, functionConfig.entrypoint, functionConfig.commands, functionConfig.scopes, functionConfig.installationId, functionConfig.providerRepositoryId, functionConfig.providerBranch, functionConfig.providerSilentMode, functionConfig.providerRootDirectory, functionConfig.specification);
+        await updateFunction(client, functionConfig);
     }
     const deployPath = functionConfig.deployDir
         ? join(resolvedPath, functionConfig.deployDir)

package/dist/functions/methods.d.ts

@@ -1,5 +1,5 @@
-import { Client, Runtime } from "node-appwrite";
-import { type Specification } from "appwrite-utils";
+import { Client } from "node-appwrite";
+import { type AppwriteFunction, type Specification } from "appwrite-utils";
 export declare const listFunctions: (client: Client, queries?: string[], search?: string) => Promise<import("node-appwrite").Models.FunctionList>;
 export declare const getFunction: (client: Client, functionId: string) => Promise<import("node-appwrite").Models.Function>;
 export declare const downloadLatestFunctionDeployment: (client: Client, functionId: string, basePath?: string) => Promise<{
@@ -8,8 +8,8 @@ export declare const downloadLatestFunctionDeployment: (client: Client, function
     deployment: import("node-appwrite").Models.Deployment;
 }>;
 export declare const deleteFunction: (client: Client, functionId: string) => Promise<{}>;
-export declare const createFunction: (client: Client, functionId: string, name: string, runtime: Runtime, execute?: string[], events?: string[], schedule?: string, timeout?: number, enabled?: boolean, logging?: boolean, entrypoint?: string, commands?: string, scopes?: string[], installationId?: string, providerRepositoryId?: string, providerBranch?: string, providerSilentMode?: boolean, providerRootDirectory?: string, templateRepository?: string, templateOwner?: string, templateRootDirectory?: string, templateVersion?: string, specification?: string) => Promise<import("node-appwrite").Models.Function>;
+export declare const createFunction: (client: Client, functionConfig: AppwriteFunction) => Promise<import("node-appwrite").Models.Function>;
 export declare const updateFunctionSpecifications: (client: Client, functionId: string, specification: Specification) => Promise<import("node-appwrite").Models.Function | undefined>;
 export declare const listSpecifications: (client: Client) => Promise<import("node-appwrite").Models.SpecificationList>;
-export declare const updateFunction: (client: Client, functionId: string, name: string, runtime?: Runtime, execute?: string[], events?: string[], schedule?: string, timeout?: number, enabled?: boolean, logging?: boolean, entrypoint?: string, commands?: string, scopes?: string[], installationId?: string, providerRepositoryId?: string, providerBranch?: string, providerSilentMode?: boolean, providerRootDirectory?: string, specification?: Specification) => Promise<import("node-appwrite").Models.Function>;
+export declare const updateFunction: (client: Client, functionConfig: AppwriteFunction) => Promise<import("node-appwrite").Models.Function>;
 export declare const createFunctionTemplate: (templateType: "typescript-node" | "poetry" | "count-docs-in-collection", functionName: string, basePath?: string) => Promise<string>;

package/dist/functions/methods.js

@@ -55,9 +55,9 @@ export const deleteFunction = async (client, functionId) => {
     const functionResponse = await functions.delete(functionId);
     return functionResponse;
 };
-export const createFunction = async (client, functionId, name, runtime, execute, events, schedule, timeout, enabled, logging, entrypoint, commands, scopes, installationId, providerRepositoryId, providerBranch, providerSilentMode, providerRootDirectory, templateRepository, templateOwner, templateRootDirectory, templateVersion, specification) => {
+export const createFunction = async (client, functionConfig) => {
     const functions = new Functions(client);
-    const functionResponse = await functions.create(functionId, name, runtime, execute, events, schedule, timeout, enabled, logging, entrypoint, commands, scopes, installationId, providerRepositoryId, providerBranch, providerSilentMode, providerRootDirectory, templateRepository, templateOwner, templateRootDirectory, templateVersion, specification);
+    const functionResponse = await functions.create(functionConfig.$id, functionConfig.name, functionConfig.runtime, functionConfig.execute, functionConfig.events, functionConfig.schedule, functionConfig.timeout, functionConfig.enabled, functionConfig.logging, functionConfig.entrypoint, functionConfig.commands, functionConfig.scopes, functionConfig.installationId, functionConfig.providerRepositoryId, functionConfig.providerBranch, functionConfig.providerSilentMode, functionConfig.providerRootDirectory, functionConfig.templateRepository, functionConfig.templateOwner, functionConfig.templateRootDirectory, functionConfig.templateVersion, functionConfig.specification);
     return functionResponse;
 };
 export const updateFunctionSpecifications = async (client, functionId, specification) => {
@@ -69,7 +69,12 @@ export const updateFunctionSpecifications = async (client, functionId, specifica
     }
     const functionFound = curFunction.functions[0];
     try {
-        const functionResponse = await updateFunction(client, functionId, functionFound.name, functionFound.runtime, functionFound.execute, functionFound.events, functionFound.schedule, functionFound.timeout, functionFound.enabled, functionFound.logging, functionFound.entrypoint, functionFound.commands, functionFound.scopes, functionFound.installationId, functionFound.providerRepositoryId, functionFound.providerBranch, functionFound.providerSilentMode, functionFound.providerRootDirectory, specification);
+        const functionResponse = await updateFunction(client, {
+            ...functionFound,
+            runtime: functionFound.runtime,
+            scopes: functionFound.scopes,
+            specification: specification,
+        });
         return functionResponse;
     }
     catch (error) {
@@ -88,9 +93,9 @@ export const listSpecifications = async (client) => {
     const specifications = await functions.listSpecifications();
     return specifications;
 };
-export const updateFunction = async (client, functionId, name, runtime, execute, events, schedule, timeout, enabled, logging, entrypoint, commands, scopes, installationId, providerRepositoryId, providerBranch, providerSilentMode, providerRootDirectory, specification) => {
+export const updateFunction = async (client, functionConfig) => {
     const functions = new Functions(client);
-    const functionResponse = await functions.update(functionId, name, runtime, execute, events, schedule, timeout, enabled, logging, entrypoint, commands, scopes, installationId, providerRepositoryId, providerBranch, providerSilentMode, providerRootDirectory, specification);
+    const functionResponse = await functions.update(functionConfig.$id, functionConfig.name, functionConfig.runtime, functionConfig.execute, functionConfig.events, functionConfig.schedule, functionConfig.timeout, functionConfig.enabled, functionConfig.logging, functionConfig.entrypoint, functionConfig.commands, functionConfig.scopes, functionConfig.installationId, functionConfig.providerRepositoryId, functionConfig.providerBranch, functionConfig.providerSilentMode, functionConfig.providerRootDirectory, functionConfig.specification);
     return functionResponse;
 };
 export const createFunctionTemplate = async (templateType, functionName, basePath = "./functions") => {

package/dist/interactiveCLI.js

@@ -291,17 +291,14 @@ export class InteractiveCLI {
         this.controller.config.functions.push(functionConfig);
         console.log(chalk.green("✨ Function created successfully!"));
     }
-    async findFunctionInSubdirectories(basePath, functionName) {
+    async findFunctionInSubdirectories(basePaths, functionName) {
         // 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
-            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()
-        ];
+        const commonPaths = basePaths.flatMap((basePath) => [
+            join(basePath, "functions", functionName),
+            join(basePath, functionName),
+            join(basePath, functionName.toLowerCase()),
+            join(basePath, functionName.toLowerCase().replace(/\s+/g, "")),
+        ]);
         // Create different variations of the function name for comparison
         const functionNameVariations = new Set([
             functionName.toLowerCase(),
@@ -324,7 +321,7 @@ export class InteractiveCLI {
         }
         // 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 queue = [...basePaths];
         const searched = new Set();
         while (queue.length > 0) {
             const currentPath = queue.shift();
@@ -383,55 +380,77 @@ export class InteractiveCLI {
             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.toLowerCase());
-                if (foundPath) {
-                    functionPath = foundPath;
-                    functionConfig.dirPath = foundPath;
+            const functionNameLower = functionConfig.name
+                .toLowerCase()
+                .replace(/\s+/g, "-");
+            // Check locations in priority order:
+            const priorityLocations = [
+                // 1. Config dirPath if specified
+                functionConfig.dirPath,
+                // 2. Appwrite config folder/functions/name
+                join(this.controller.getAppwriteFolderPath(), "functions", functionNameLower),
+                // 3. Current working directory/functions/name
+                join(process.cwd(), "functions", functionNameLower),
+                // 4. Current working directory/name
+                join(process.cwd(), functionNameLower),
+            ].filter((val) => val !== undefined); // Remove undefined entries (in case dirPath is undefined)
+            let functionPath = null;
+            // Check each priority location
+            for (const location of priorityLocations) {
+                if (fs.existsSync(location)) {
+                    console.log(chalk.green(`Found function at: ${location}`));
+                    functionPath = location;
+                    break;
                 }
-                else {
-                    const { shouldDownload } = await inquirer.prompt([
-                        {
-                            type: "confirm",
-                            name: "shouldDownload",
-                            message: "Function not found locally. 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}`));
-                            const existingIndex = this.controller.config.functions.findIndex((f) => f?.$id === remoteFunction.$id);
-                            if (existingIndex >= 0) {
-                                // Only update the dirPath if function exists
-                                this.controller.config.functions[existingIndex].dirPath =
-                                    downloadedPath;
-                            }
-                            await this.controller.reloadConfig();
-                            functionConfig.dirPath = downloadedPath;
-                            functionPath = downloadedPath;
-                        }
-                        catch (error) {
-                            console.error(chalk.red("Failed to download function deployment:"), error);
-                            return;
+            }
+            // If not found in priority locations, do a broader search
+            if (!functionPath) {
+                console.log(chalk.yellow(`Function not found in primary locations, searching subdirectories...`));
+                // Search in both appwrite config directory and current working directory
+                functionPath = await this.findFunctionInSubdirectories([this.controller.getAppwriteFolderPath(), process.cwd()], functionNameLower);
+            }
+            if (!functionPath) {
+                const { shouldDownload } = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "shouldDownload",
+                        message: "Function not found locally. 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}`));
+                        functionPath = downloadedPath;
+                        functionConfig.dirPath = downloadedPath;
+                        const existingIndex = this.controller.config.functions.findIndex((f) => f?.$id === remoteFunction.$id);
+                        if (existingIndex >= 0) {
+                            this.controller.config.functions[existingIndex].dirPath =
+                                downloadedPath;
                         }
+                        await this.controller.reloadConfig();
                     }
-                    else {
-                        console.log(chalk.red(`Function ${functionConfig.name} not found locally. Cannot deploy.`));
+                    catch (error) {
+                        console.error(chalk.red("Failed to download function deployment:"), error);
                         return;
                     }
                 }
+                else {
+                    console.log(chalk.red(`Function ${functionConfig.name} not found locally. Cannot deploy.`));
+                    return;
+                }
             }
             if (!this.controller.appwriteServer) {
                 console.log(chalk.red("Appwrite server not initialized"));
                 return;
             }
             try {
-                await deployLocalFunction(this.controller.appwriteServer, functionConfig.name, functionConfig);
+                await deployLocalFunction(this.controller.appwriteServer, functionConfig.name, {
+                    ...functionConfig,
+                    dirPath: functionPath,
+                });
                 console.log(chalk.green("✨ Function deployed successfully!"));
             }
             catch (error) {
@@ -499,7 +518,14 @@ export class InteractiveCLI {
             logging: f.logging !== false,
             entrypoint: f.entrypoint || "src/index.ts",
             commands: f.commands || "npm install",
+            scopes: f.scopes || [], // Add scopes
             path: f.dirPath || `functions/${f.name}`,
+            dirPath: f.dirPath, // Preserve original dirPath
+            installationId: f.installationId || "",
+            providerRepositoryId: f.providerRepositoryId || "",
+            providerBranch: f.providerBranch || "",
+            providerSilentMode: f.providerSilentMode || false,
+            providerRootDirectory: f.providerRootDirectory || "",
             ...(f.specification ? { specification: f.specification } : {}),
             ...(f.predeployCommands
                 ? { predeployCommands: f.predeployCommands }
@@ -808,7 +834,7 @@ export class InteractiveCLI {
                     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);
+                        const foundPath = await this.findFunctionInSubdirectories([this.controller.getAppwriteFolderPath(), process.cwd()], func.name);
                         if (foundPath) {
                             console.log(chalk.green(`Found function at: ${foundPath}`));
                             functionPath = foundPath;
@@ -876,7 +902,7 @@ export class InteractiveCLI {
                     // 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);
+                        const foundPath = await this.findFunctionInSubdirectories([this.controller.getAppwriteFolderPath(), process.cwd()], func.name);
                         if (foundPath) {
                             functionPath = foundPath;
                         }

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.10.62",
+  "version": "0.10.64",
   "main": "src/main.ts",
   "type": "module",
   "repository": {
@@ -31,7 +31,7 @@
   },
   "dependencies": {
     "@types/inquirer": "^9.0.7",
-    "appwrite-utils": "^0.3.98",
+    "appwrite-utils": "^0.3.99",
     "chalk": "^5.3.0",
     "cli-progress": "^3.12.0",
     "commander": "^12.1.0",

package/src/functions/deployments.ts

@@ -57,6 +57,18 @@ export const deployFunction = async (
 
   const tarPath = join(process.cwd(), `function-${functionId}.tar.gz`);
 
+  // Verify codePath exists and is a directory
+  if (!fs.existsSync(codePath)) {
+    throw new Error(`Function directory not found at ${codePath}`);
+  }
+
+  const stats = await fs.promises.stat(codePath);
+  if (!stats.isDirectory()) {
+    throw new Error(`${codePath} is not a directory`);
+  }
+
+  console.log(chalk.blue(`Creating tarball from ${codePath}`));
+
   const progressBar = new cliProgress.SingleBar({
     format:
       "Uploading |" +
@@ -77,14 +89,22 @@ export const deployFunction = async (
           codePath,
           join(codePath, path)
         ).toLowerCase();
-        return !ignoredLower.some(
-          (pattern) =>
-            relativePath.startsWith(pattern) ||
-            relativePath.includes(`/${pattern}`)
-        );
+        // Skip if path matches any ignored pattern
+        if (
+          ignoredLower.some(
+            (pattern) =>
+              relativePath.startsWith(pattern) ||
+              relativePath.includes(`/${pattern}`) ||
+              relativePath.includes(`\\${pattern}`)
+          )
+        ) {
+          console.log(chalk.gray(`Ignoring ${path}`));
+          return false;
+        }
+        return true;
       },
     },
-    ["."]
+    ["."] // This now only includes contents of codePath since we set cwd to codePath
   );
 
   const fileBuffer = await fs.promises.readFile(tarPath);
@@ -194,54 +214,10 @@ export const deployLocalFunction = async (
 
   // Only create function if it doesn't exist
   if (!functionExists) {
-    await createFunction(
-      client,
-      functionConfig.$id,
-      functionConfig.name,
-      functionConfig.runtime as Runtime,
-      functionConfig.execute,
-      functionConfig.events,
-      functionConfig.schedule,
-      functionConfig.timeout,
-      functionConfig.enabled,
-      functionConfig.logging,
-      functionConfig.entrypoint,
-      functionConfig.commands,
-      functionConfig.scopes,
-      functionConfig.installationId,
-      functionConfig.providerRepositoryId,
-      functionConfig.providerBranch,
-      functionConfig.providerSilentMode,
-      functionConfig.providerRootDirectory,
-      functionConfig.templateRepository,
-      functionConfig.templateOwner,
-      functionConfig.templateRootDirectory,
-      functionConfig.templateVersion,
-      functionConfig.specification
-    );
+    await createFunction(client, functionConfig);
   } else {
     console.log(chalk.blue("Updating function..."));
-    await updateFunction(
-      client,
-      functionConfig.$id,
-      functionConfig.name,
-      functionConfig.runtime as Runtime,
-      functionConfig.execute,
-      functionConfig.events,
-      functionConfig.schedule,
-      functionConfig.timeout,
-      functionConfig.enabled,
-      functionConfig.logging,
-      functionConfig.entrypoint,
-      functionConfig.commands,
-      functionConfig.scopes,
-      functionConfig.installationId,
-      functionConfig.providerRepositoryId,
-      functionConfig.providerBranch,
-      functionConfig.providerSilentMode,
-      functionConfig.providerRootDirectory,
-      functionConfig.specification
-    );
+    await updateFunction(client, functionConfig);
   }
 
   const deployPath = functionConfig.deployDir

package/src/functions/methods.ts

@@ -7,7 +7,11 @@ import {
 } from "node-appwrite";
 import { join } from "node:path";
 import fs from "node:fs";
-import { type Specification } from "appwrite-utils";
+import {
+  type AppwriteFunction,
+  type FunctionScope,
+  type Specification,
+} from "appwrite-utils";
 import chalk from "chalk";
 import { extract as extractTar } from "tar";
 
@@ -87,53 +91,32 @@ export const deleteFunction = async (client: Client, functionId: string) => {
 
 export const createFunction = async (
   client: Client,
-  functionId: string,
-  name: string,
-  runtime: Runtime,
-  execute?: string[],
-  events?: string[],
-  schedule?: string,
-  timeout?: number,
-  enabled?: boolean,
-  logging?: boolean,
-  entrypoint?: string,
-  commands?: string,
-  scopes?: string[],
-  installationId?: string,
-  providerRepositoryId?: string,
-  providerBranch?: string,
-  providerSilentMode?: boolean,
-  providerRootDirectory?: string,
-  templateRepository?: string,
-  templateOwner?: string,
-  templateRootDirectory?: string,
-  templateVersion?: string,
-  specification?: string
+  functionConfig: AppwriteFunction
 ) => {
   const functions = new Functions(client);
   const functionResponse = await functions.create(
-    functionId,
-    name,
-    runtime,
-    execute,
-    events,
-    schedule,
-    timeout,
-    enabled,
-    logging,
-    entrypoint,
-    commands,
-    scopes,
-    installationId,
-    providerRepositoryId,
-    providerBranch,
-    providerSilentMode,
-    providerRootDirectory,
-    templateRepository,
-    templateOwner,
-    templateRootDirectory,
-    templateVersion,
-    specification
+    functionConfig.$id,
+    functionConfig.name,
+    functionConfig.runtime as Runtime,
+    functionConfig.execute,
+    functionConfig.events,
+    functionConfig.schedule,
+    functionConfig.timeout,
+    functionConfig.enabled,
+    functionConfig.logging,
+    functionConfig.entrypoint,
+    functionConfig.commands,
+    functionConfig.scopes,
+    functionConfig.installationId,
+    functionConfig.providerRepositoryId,
+    functionConfig.providerBranch,
+    functionConfig.providerSilentMode,
+    functionConfig.providerRootDirectory,
+    functionConfig.templateRepository,
+    functionConfig.templateOwner,
+    functionConfig.templateRootDirectory,
+    functionConfig.templateVersion,
+    functionConfig.specification
   );
   return functionResponse;
 };
@@ -151,27 +134,12 @@ export const updateFunctionSpecifications = async (
   }
   const functionFound = curFunction.functions[0];
   try {
-    const functionResponse = await updateFunction(
-      client,
-      functionId,
-      functionFound.name,
-      functionFound.runtime as Runtime,
-      functionFound.execute,
-      functionFound.events,
-      functionFound.schedule,
-      functionFound.timeout,
-      functionFound.enabled,
-      functionFound.logging,
-      functionFound.entrypoint,
-      functionFound.commands,
-      functionFound.scopes,
-      functionFound.installationId,
-      functionFound.providerRepositoryId,
-      functionFound.providerBranch,
-      functionFound.providerSilentMode,
-      functionFound.providerRootDirectory,
-      specification
-    );
+    const functionResponse = await updateFunction(client, {
+      ...functionFound,
+      runtime: functionFound.runtime as Runtime,
+      scopes: functionFound.scopes as FunctionScope[],
+      specification: specification,
+    });
     return functionResponse;
   } catch (error) {
     if (
@@ -198,45 +166,28 @@ export const listSpecifications = async (client: Client) => {
 
 export const updateFunction = async (
   client: Client,
-  functionId: string,
-  name: string,
-  runtime?: Runtime,
-  execute?: string[],
-  events?: string[],
-  schedule?: string,
-  timeout?: number,
-  enabled?: boolean,
-  logging?: boolean,
-  entrypoint?: string,
-  commands?: string,
-  scopes?: string[],
-  installationId?: string,
-  providerRepositoryId?: string,
-  providerBranch?: string,
-  providerSilentMode?: boolean,
-  providerRootDirectory?: string,
-  specification?: Specification
+  functionConfig: AppwriteFunction
 ) => {
   const functions = new Functions(client);
   const functionResponse = await functions.update(
-    functionId,
-    name,
-    runtime,
-    execute,
-    events,
-    schedule,
-    timeout,
-    enabled,
-    logging,
-    entrypoint,
-    commands,
-    scopes,
-    installationId,
-    providerRepositoryId,
-    providerBranch,
-    providerSilentMode,
-    providerRootDirectory,
-    specification
+    functionConfig.$id,
+    functionConfig.name,
+    functionConfig.runtime as Runtime,
+    functionConfig.execute,
+    functionConfig.events,
+    functionConfig.schedule,
+    functionConfig.timeout,
+    functionConfig.enabled,
+    functionConfig.logging,
+    functionConfig.entrypoint,
+    functionConfig.commands,
+    functionConfig.scopes,
+    functionConfig.installationId,
+    functionConfig.providerRepositoryId,
+    functionConfig.providerBranch,
+    functionConfig.providerSilentMode,
+    functionConfig.providerRootDirectory,
+    functionConfig.specification
   );
   return functionResponse;
 };

package/src/interactiveCLI.ts

@@ -389,19 +389,16 @@ export class InteractiveCLI {
   }
 
   private async findFunctionInSubdirectories(
-    basePath: string,
+    basePaths: string[],
     functionName: string
   ): Promise<string | null> {
     // 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
-      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()
-    ];
+    const commonPaths = basePaths.flatMap((basePath) => [
+      join(basePath, "functions", functionName),
+      join(basePath, functionName),
+      join(basePath, functionName.toLowerCase()),
+      join(basePath, functionName.toLowerCase().replace(/\s+/g, "")),
+    ]);
 
     // Create different variations of the function name for comparison
     const functionNameVariations = new Set([
@@ -433,7 +430,7 @@ export class InteractiveCLI {
       )
     );
 
-    const queue = [process.cwd(), basePath];
+    const queue = [...basePaths];
     const searched = new Set<string>();
 
     while (queue.length > 0) {
@@ -515,78 +512,103 @@ export class InteractiveCLI {
         this.controller.config.functions = [];
       }
 
-      let functionPath = join(
-        this.controller.getAppwriteFolderPath(),
-        "functions",
-        functionConfig.name
-      );
+      const functionNameLower = functionConfig.name
+        .toLowerCase()
+        .replace(/\s+/g, "-");
+
+      // Check locations in priority order:
+      const priorityLocations = [
+        // 1. Config dirPath if specified
+        functionConfig.dirPath,
+        // 2. Appwrite config folder/functions/name
+        join(
+          this.controller.getAppwriteFolderPath(),
+          "functions",
+          functionNameLower
+        ),
+        // 3. Current working directory/functions/name
+        join(process.cwd(), "functions", functionNameLower),
+        // 4. Current working directory/name
+        join(process.cwd(), functionNameLower),
+      ].filter((val): val is string => val !== undefined); // Remove undefined entries (in case dirPath is undefined)
+
+      let functionPath: string | null = null;
+
+      // Check each priority location
+      for (const location of priorityLocations) {
+        if (fs.existsSync(location)) {
+          console.log(chalk.green(`Found function at: ${location}`));
+          functionPath = location;
+          break;
+        }
+      }
 
-      if (!fs.existsSync(functionPath)) {
+      // If not found in priority locations, do a broader search
+      if (!functionPath) {
         console.log(
           chalk.yellow(
-            `Function not found in primary location, searching subdirectories...`
+            `Function not found in primary locations, searching subdirectories...`
           )
         );
-        const foundPath = await this.findFunctionInSubdirectories(
-          this.controller.getAppwriteFolderPath(),
-          functionConfig.name.toLowerCase()
+
+        // Search in both appwrite config directory and current working directory
+        functionPath = await this.findFunctionInSubdirectories(
+          [this.controller.getAppwriteFolderPath(), process.cwd()],
+          functionNameLower
         );
+      }
 
-        if (foundPath) {
-          functionPath = foundPath;
-          functionConfig.dirPath = foundPath;
-        } else {
-          const { shouldDownload } = await inquirer.prompt([
-            {
-              type: "confirm",
-              name: "shouldDownload",
-              message:
-                "Function not found locally. Would you like to download the latest deployment?",
-              default: false,
-            },
-          ]);
+      if (!functionPath) {
+        const { shouldDownload } = await inquirer.prompt([
+          {
+            type: "confirm",
+            name: "shouldDownload",
+            message:
+              "Function not found locally. 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}`)
+        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 existingIndex = this.controller.config.functions.findIndex(
-                (f) => f?.$id === remoteFunction.$id
-              );
+            functionPath = downloadedPath;
+            functionConfig.dirPath = downloadedPath;
 
-              if (existingIndex >= 0) {
-                // Only update the dirPath if function exists
-                this.controller.config.functions[existingIndex].dirPath =
-                  downloadedPath;
-              }
-
-              await this.controller.reloadConfig();
-              functionConfig.dirPath = downloadedPath;
-              functionPath = downloadedPath;
-            } catch (error) {
-              console.error(
-                chalk.red("Failed to download function deployment:"),
-                error
-              );
-              return;
+            const existingIndex = this.controller.config.functions.findIndex(
+              (f) => f?.$id === remoteFunction.$id
+            );
+
+            if (existingIndex >= 0) {
+              this.controller.config.functions[existingIndex].dirPath =
+                downloadedPath;
             }
-          } else {
-            console.log(
-              chalk.red(
-                `Function ${functionConfig.name} not found locally. Cannot deploy.`
-              )
+
+            await this.controller.reloadConfig();
+          } catch (error) {
+            console.error(
+              chalk.red("Failed to download function deployment:"),
+              error
             );
             return;
           }
+        } else {
+          console.log(
+            chalk.red(
+              `Function ${functionConfig.name} not found locally. Cannot deploy.`
+            )
+          );
+          return;
         }
       }
 
@@ -599,7 +621,10 @@ export class InteractiveCLI {
         await deployLocalFunction(
           this.controller.appwriteServer,
           functionConfig.name,
-          functionConfig
+          {
+            ...functionConfig,
+            dirPath: functionPath,
+          }
         );
         console.log(chalk.green("✨ Function deployed successfully!"));
       } catch (error) {
@@ -691,7 +716,14 @@ export class InteractiveCLI {
       logging: f.logging !== false,
       entrypoint: f.entrypoint || "src/index.ts",
       commands: f.commands || "npm install",
+      scopes: f.scopes || [], // Add scopes
       path: f.dirPath || `functions/${f.name}`,
+      dirPath: f.dirPath, // Preserve original dirPath
+      installationId: f.installationId || "",
+      providerRepositoryId: f.providerRepositoryId || "",
+      providerBranch: f.providerBranch || "",
+      providerSilentMode: f.providerSilentMode || false,
+      providerRootDirectory: f.providerRootDirectory || "",
       ...(f.specification ? { specification: f.specification } : {}),
       ...(f.predeployCommands
         ? { predeployCommands: f.predeployCommands }
@@ -1119,7 +1151,7 @@ export class InteractiveCLI {
               )
             );
             const foundPath = await this.findFunctionInSubdirectories(
-              this.controller!.getAppwriteFolderPath(),
+              [this.controller!.getAppwriteFolderPath(), process.cwd()],
               func.name
             );
 
@@ -1210,7 +1242,7 @@ export class InteractiveCLI {
 
           if (!fs.existsSync(functionPath)) {
             const foundPath = await this.findFunctionInSubdirectories(
-              this.controller!.getAppwriteFolderPath(),
+              [this.controller!.getAppwriteFolderPath(), process.cwd()],
               func.name
             );