diff --git a/OpenclawSkill.md b/OpenclawSkill.md
new file mode 100644
index 0000000..fa46967
--- /dev/null
+++ b/OpenclawSkill.md
@@ -0,0 +1,48 @@
+---
+name: shsf
+description: Interact with the users shsf instance to manage serverless functions, namespaces, triggers, schedules, and more via the CLI.
+---
+
+# SHSF - Selfhostable Serverless Functions; THE CLI
+The `shsf` CLI tool allows you to interact with your shsf instance to manage serverless functions, namespaces, triggers, schedules, and more. Below are the available commands and their descriptions.
+
+## Setup
+To get started, you need to set up the `shsf` CLI tool. Follow the instructions below to install and configure it.
+
+1. Run this
+```bash
+shsf health
+```
+this will check the health, and if not setup, it will prompt you to set up the CLI.
+
+## Commands
+
+### Count
+- `shsf count functions`: Count your functions. Add `--full` to list them.
+- `shsf count namespaces`: Count your namespaces. Add `--full` to list them.
+- `shsf count storages`: Count your storages. Add `--full` to list them.
+- `shsf count triggers`: Count your triggers. Add `--full` to list them.
+
+- `shsf create function`: Create a new function. (use `shsf create function -h` first)
+- `shsf create namespace`: Create a new namespace. (use `shsf create namespace -h` first)
+- `shsf create trigger`: Create a new trigger. (use `shsf create trigger -h` first)
+
+- `shsf delete function <id>`: Deletes a specific serverless function by its ID.
+- `shsf delete namespace <id>`: Deletes a namespace and all its functions by ID.
+- `shsf delete trigger <functionId> <triggerId>`: Deletes a specific trigger from a function.
+
+- `shsf get function <id>`: Get details of a specific function by its ID.
+- `shsf get namespace <id>`: Get details of a specific namespace by its ID
+- `shsf get trigger <functionId> <triggerId>`: Get details of a specific trigger from a function.
+
+- `shsf update function <id>`: Update a specific serverless function by its ID. (use `shsf update function -h` first)
+- `shsf update namespace <id>`: Update a specific namespace by its ID. (use `shsf update namespace -h` first)
+- `shsf update trigger <functionId> <triggerId>`: Update a specific trigger from a function. (use `shsf update trigger -h` first)
+
+- `shsf file create`: Create a file in a storage. (use `shsf file create -h` first)
+- `shsf file overwrite`: Overwrite an existing file in a storage. (use `shsf file overwrite -h` first)
+- `shsf file delete`: Delete a file from a storage. (use `shsf file delete -h` first)
+- `shsf file list`: List files in a storage. (use `shsf file list -h` first)
+
+## Instructions
+Use these commands for when you need to interact with shsf from the command line. Its faster than using the ui for almost all ops.
\ No newline at end of file
diff --git a/package.json b/package.json
index 9754990..6e50562 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "shsf-cli",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "description": "",
   "type": "module",
   "files": [
diff --git a/src/commands/count/functions.ts b/src/commands/count/functions.ts
index 4c1c975..0665319 100644
--- a/src/commands/count/functions.ts
+++ b/src/commands/count/functions.ts
@@ -4,12 +4,15 @@ import { getApiClient } from "../../api.js";
 export const functionsCountDefinition = {
   name: "functions",
   description: "Counts the amount of functions the current user has.",
-  action: async () => {
-    await countFunctions();
+  options: [
+    { name: "--full", description: "List all functions instead of just the count", type: "boolean" },
+  ],
+  action: async (options: any) => {
+    await countFunctions(options?.full);
   },
 };
 
-async function countFunctions() {
+async function countFunctions(full: boolean = false) {
   const client = await getApiClient();
 
   try {
@@ -19,7 +22,7 @@ async function countFunctions() {
       const functions = response.data.data;
       const count = functions.length;
 
-      if (count > 0) {
+      if (full && count > 0) {
         console.log(chalk.blue("Functions List:"));
         functions.forEach((f: any) => {
           const namespaceInfo = f.namespace ? chalk.gray(` [NS: ${f.namespace.id}]`) : "";
diff --git a/src/commands/count/namespaces.ts b/src/commands/count/namespaces.ts
index cda9a44..09b511f 100644
--- a/src/commands/count/namespaces.ts
+++ b/src/commands/count/namespaces.ts
@@ -4,12 +4,15 @@ import { getApiClient } from "../../api.js";
 export const namespacesCountDefinition = {
   name: "namespaces",
   description: "Counts the amount of namespaces the current user has.",
-  action: async () => {
-    await countNamespaces();
+  options: [
+    { name: "--full", description: "List all namespaces instead of just the count", type: "boolean" },
+  ],
+  action: async (options: any) => {
+    await countNamespaces(options?.full);
   },
 };
 
-async function countNamespaces() {
+async function countNamespaces(full: boolean = false) {
   const client = await getApiClient();
 
   try {
@@ -19,7 +22,7 @@ async function countNamespaces() {
       const namespaces = response.data.data;
       const count = namespaces.length;
 
-      if (count > 0) {
+      if (full && count > 0) {
         console.log(chalk.blue("Namespaces List:"));
         namespaces.forEach((ns: any) => {
           console.log(`- ${chalk.cyan(ns.name)} ${chalk.gray(`(${ns.id})`)}`);
diff --git a/src/commands/count/storages.ts b/src/commands/count/storages.ts
index 9a83883..fa6e5c7 100644
--- a/src/commands/count/storages.ts
+++ b/src/commands/count/storages.ts
@@ -4,12 +4,15 @@ import { getApiClient } from "../../api.js";
 export const storagesCountDefinition = {
   name: "storages",
   description: "Counts the amount of storages the current user has.",
-  action: async () => {
-    await countStorages();
+  options: [
+    { name: "--full", description: "List all storages instead of just the count", type: "boolean" },
+  ],
+  action: async (options: any) => {
+    await countStorages(options?.full);
   },
 };
 
-async function countStorages() {
+async function countStorages(full: boolean = false) {
   const client = await getApiClient();
 
   try {
@@ -19,7 +22,7 @@ async function countStorages() {
       const storages = response.data.data;
       const count = storages.length;
 
-      if (count > 0) {
+      if (full && count > 0) {
         console.log(chalk.blue("Storages List:"));
         storages.forEach((s: any) => {
           const purposeInfo = s.purpose ? chalk.gray(` - ${s.purpose}`) : "";
diff --git a/src/commands/count/triggers.ts b/src/commands/count/triggers.ts
index 889f3dc..0bda6bd 100644
--- a/src/commands/count/triggers.ts
+++ b/src/commands/count/triggers.ts
@@ -4,12 +4,15 @@ import { getApiClient } from "../../api.js";
 export const triggersCountDefinition = {
   name: "triggers",
   description: "Counts the amount of triggers the current user has.",
-  action: async () => {
-    await countTriggers();
+  options: [
+    { name: "--full", description: "List all triggers instead of just the count", type: "boolean" },
+  ],
+  action: async (options: any) => {
+    await countTriggers(options?.full);
   },
 };
 
-async function countTriggers() {
+async function countTriggers(full: boolean = false) {
   const client = await getApiClient();
 
   try {
@@ -19,7 +22,7 @@ async function countTriggers() {
       const triggers = response.data.data;
       const count = triggers.length;
 
-      if (count > 0) {
+      if (full && count > 0) {
         console.log(chalk.blue("Triggers List:"));
         triggers.forEach((t: any) => {
           const functionInfo = t.function ? chalk.gray(` [Func: ${t.function.name}]`) : "";
diff --git a/src/commands/create/function.ts b/src/commands/create/function.ts
index f20b83f..1fb35a1 100644
--- a/src/commands/create/function.ts
+++ b/src/commands/create/function.ts
@@ -14,8 +14,26 @@ export const createFunctionDefinition = {
     { name: "--docker-mount", description: "Enable Docker mount", type: "boolean" },
     { name: "--ffmpeg-install", description: "Install ffmpeg in container", type: "boolean" },
     { name: "--imported", description: "Marks the function as imported", type: "boolean" },
+    { name: "--cache-enabled <enabled>", description: "Enable response caching (true/false)" },
+    { name: "--cache-ttl <seconds>", description: "Cache TTL in seconds" },
   ],
   action: async (options: any) => {
+    let parsedCacheEnabled: boolean | undefined;
+    if (options.cacheEnabled !== undefined) {
+      const normalized = String(options.cacheEnabled).toLowerCase();
+      if (normalized !== "true" && normalized !== "false") {
+        console.error(`${chalk.red("✗")} Invalid value for --cache-enabled. Use true or false.`);
+        return;
+      }
+      parsedCacheEnabled = normalized === "true";
+    }
+
+    const parsedCacheTtl = options.cacheTtl !== undefined ? Number(options.cacheTtl) : undefined;
+    if (parsedCacheTtl !== undefined && Number.isNaN(parsedCacheTtl)) {
+      console.error(`${chalk.red("✗")} Invalid value for --cache-ttl. Please provide a number.`);
+      return;
+    }
+
     const data = {
       name: options.name,
       description: options.description,
@@ -26,6 +44,8 @@ export const createFunctionDefinition = {
       docker_mount: !!options.dockerMount,
       ffmpeg_install: !!options.ffmpegInstall,
       imported: !!options.imported,
+      cache_enabled: parsedCacheEnabled,
+      cache_ttl: parsedCacheTtl,
     };
 
     const client = await getApiClient();
diff --git a/src/commands/create/namespace.ts b/src/commands/create/namespace.ts
new file mode 100644
index 0000000..25515c4
--- /dev/null
+++ b/src/commands/create/namespace.ts
@@ -0,0 +1,41 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const createNamespaceDefinition = {
+  name: "namespace",
+  description: "Create a new namespace.",
+  options: [
+    { name: "--name <name>", description: "Namespace name", required: true },
+    { name: "--description <description>", description: "Namespace description", required: true },
+  ],
+  action: async (options: any) => {
+    const data = {
+      name: options.name,
+      description: options.description,
+    };
+
+    const client = await getApiClient();
+
+    try {
+      const response = await client.post("/api/namespaces", data);
+
+      if (response.status === 200 || response.status === 201) {
+        console.log(
+          `${chalk.green("✓")} Namespace ${chalk.cyan(data.name)} created successfully! ID: ${chalk.bgGreen.black(` ${response.data.data.id} `)}`,
+        );
+      } else {
+        console.log(
+          `${chalk.yellow("!")} Unexpected response from server: ${response.status}`,
+        );
+      }
+    } catch (error: any) {
+      if (error.response) {
+        console.error(
+          `${chalk.red("✗")} Failed to create namespace: ${chalk.yellow(error.response.data.message || "Unknown error")}`,
+        );
+      } else {
+        console.error(`${chalk.red("✗")} Error: ${error.message}`);
+      }
+    }
+  },
+};
diff --git a/src/commands/create/trigger.ts b/src/commands/create/trigger.ts
new file mode 100644
index 0000000..52df58d
--- /dev/null
+++ b/src/commands/create/trigger.ts
@@ -0,0 +1,44 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const createTriggerDefinition = {
+  name: "trigger",
+  description: "Create a new trigger for a function.",
+  options: [
+    { name: "--function-id <id>", description: "The ID of the function to add the trigger to", required: true },
+    { name: "--name <name>", description: "Trigger name", required: true },
+    { name: "--description <description>", description: "Trigger description", required: true },
+  ],
+  action: async (options: any) => {
+    const { functionId, name, description } = options;
+
+    const data = {
+      name,
+      description,
+    };
+
+    const client = await getApiClient();
+
+    try {
+      const response = await client.post(`/api/functions/${functionId}/triggers`, data);
+
+      if (response.status === 200 || response.status === 201) {
+        console.log(
+          `${chalk.green("✓")} Trigger ${chalk.cyan(name)} created successfully for function ID ${chalk.cyan(functionId)}! ID: ${chalk.bgGreen.black(` ${response.data.data.id} `)}`,
+        );
+      } else {
+        console.log(
+          `${chalk.yellow("!")} Unexpected response from server: ${response.status}`,
+        );
+      }
+    } catch (error: any) {
+      if (error.response) {
+        console.error(
+          `${chalk.red("✗")} Failed to create trigger: ${chalk.yellow(error.response.data.message || "Unknown error")}`,
+        );
+      } else {
+        console.error(`${chalk.red("✗")} Error: ${error.message}`);
+      }
+    }
+  },
+};
diff --git a/src/commands/delete/function.ts b/src/commands/delete/function.ts
new file mode 100644
index 0000000..6a25e05
--- /dev/null
+++ b/src/commands/delete/function.ts
@@ -0,0 +1,47 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const deleteFunctionDefinition = {
+  name: "function <id>",
+  description: "Deletes a specific serverless function by its ID.",
+  action: async (id: string) => {
+    await deleteFunction(id);
+  },
+};
+
+async function deleteFunction(id: string) {
+  const client = await getApiClient();
+
+  try {
+    const response = await client.delete(`/api/function/${id}`);
+
+    if (response.status === 200) {
+      console.log(
+        `${chalk.green("✓")} Function with ID ${chalk.cyan(id)} has been deleted.`,
+      );
+    } else {
+      console.log(
+        `${chalk.yellow("!")} Unexpected response from server.`,
+      );
+      console.log(`Status Code: ${chalk.blue(response.status)}`);
+    }
+  } catch (error: any) {
+    if (error.response) {
+      if (error.response.status === 404) {
+        console.error(`${chalk.red("✗")} Function with ID ${chalk.yellow(id)} not found.`);
+      } else {
+        console.error(
+          `${chalk.red("✗")} Failed to delete function.`,
+        );
+        console.error(`Status Code: ${chalk.red(error.response.status)}`);
+        console.error(
+          `Message: ${chalk.yellow(error.response.data.message || "Unknown error from server")}`,
+        );
+      }
+    } else if (error.request) {
+      console.error(`${chalk.red("✗")} No response received from server.`);
+    } else {
+      console.error(`${chalk.red("✗")} Error:`, error.message);
+    }
+  }
+}
diff --git a/src/commands/delete/namespace.ts b/src/commands/delete/namespace.ts
new file mode 100644
index 0000000..a66894d
--- /dev/null
+++ b/src/commands/delete/namespace.ts
@@ -0,0 +1,47 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const deleteNamespaceDefinition = {
+  name: "namespace <id>",
+  description: "Deletes a namespace and all its functions by ID.",
+  action: async (id: string) => {
+    await deleteNamespace(id);
+  },
+};
+
+async function deleteNamespace(id: string) {
+  const client = await getApiClient();
+
+  try {
+    const response = await client.delete(`/api/namespace/${id}`);
+
+    if (response.status === 200) {
+      console.log(
+        `${chalk.green("✓")} Namespace with ID ${chalk.cyan(id)} has been deleted.`,
+      );
+    } else {
+      console.log(
+        `${chalk.yellow("!")} Unexpected response from server.`,
+      );
+      console.log(`Status Code: ${chalk.blue(response.status)}`);
+    }
+  } catch (error: any) {
+    if (error.response) {
+      if (error.response.status === 404) {
+        console.error(`${chalk.red("✗")} Namespace with ID ${chalk.yellow(id)} not found.`);
+      } else {
+        console.error(
+          `${chalk.red("✗")} Failed to delete namespace.`,
+        );
+        console.error(`Status Code: ${chalk.red(error.response.status)}`);
+        console.error(
+          `Message: ${chalk.yellow(error.response.data.message || "Unknown error from server")}`,
+        );
+      }
+    } else if (error.request) {
+      console.error(`${chalk.red("✗")} No response received from server.`);
+    } else {
+      console.error(`${chalk.red("✗")} Error:`, error.message);
+    }
+  }
+}
diff --git a/src/commands/delete/trigger.ts b/src/commands/delete/trigger.ts
new file mode 100644
index 0000000..8f7e07f
--- /dev/null
+++ b/src/commands/delete/trigger.ts
@@ -0,0 +1,47 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const deleteTriggerDefinition = {
+  name: "trigger <functionId> <triggerId>",
+  description: "Deletes a specific trigger from a function.",
+  action: async (functionId: string, triggerId: string) => {
+    await deleteTrigger(functionId, triggerId);
+  },
+};
+
+async function deleteTrigger(functionId: string, triggerId: string) {
+  const client = await getApiClient();
+
+  try {
+    const response = await client.delete(`/api/functions/${functionId}/triggers/${triggerId}`);
+
+    if (response.status === 200) {
+      console.log(
+        `${chalk.green("✓")} Trigger with ID ${chalk.cyan(triggerId)} from function ${chalk.cyan(functionId)} has been deleted.`,
+      );
+    } else {
+      console.log(
+        `${chalk.yellow("!")} Unexpected response from server.`,
+      );
+      console.log(`Status Code: ${chalk.blue(response.status)}`);
+    }
+  } catch (error: any) {
+    if (error.response) {
+      if (error.response.status === 404) {
+        console.error(`${chalk.red("✗")} Trigger or function not found.`);
+      } else {
+        console.error(
+          `${chalk.red("✗")} Failed to delete trigger.`,
+        );
+        console.error(`Status Code: ${chalk.red(error.response.status)}`);
+        console.error(
+          `Message: ${chalk.yellow(error.response.data.message || "Unknown error from server")}`,
+        );
+      }
+    } else if (error.request) {
+      console.error(`${chalk.red("✗")} No response received from server.`);
+    } else {
+      console.error(`${chalk.red("✗")} Error:`, error.message);
+    }
+  }
+}
diff --git a/src/commands/file/create.ts b/src/commands/file/create.ts
new file mode 100644
index 0000000..86b22ef
--- /dev/null
+++ b/src/commands/file/create.ts
@@ -0,0 +1,63 @@
+import chalk from "chalk";
+import fs from "fs/promises";
+import { getApiClient } from "../../api.js";
+
+export const fileCreateDefinition = {
+  name: "create",
+  description: "Create a file in a storage.",
+  options: [
+    { name: "--storage-id <id>", description: "Storage ID", required: true },
+    { name: "--path <path>", description: "Remote file path", required: true },
+    { name: "--content <content>", description: "Inline file content" },
+    { name: "--source <source>", description: "Local source file path" },
+  ],
+  action: async (options: any) => {
+    if (!options.content && !options.source) {
+      console.error(`${chalk.red("✗")} You must provide either --content or --source.`);
+      return;
+    }
+
+    if (options.content && options.source) {
+      console.error(`${chalk.red("✗")} Please provide only one of --content or --source.`);
+      return;
+    }
+
+    let content = options.content;
+    if (options.source) {
+      try {
+        content = await fs.readFile(options.source, "utf8");
+      } catch (error: any) {
+        console.error(`${chalk.red("✗")} Failed to read source file: ${chalk.yellow(error.message)}`);
+        return;
+      }
+    }
+
+    const client = await getApiClient();
+    const payload = {
+      path: options.path,
+      content,
+    };
+
+    try {
+      const response = await client.post(`/api/storage/${options.storageId}/files`, payload);
+
+      if (response.status === 200 || response.status === 201) {
+        console.log(
+          `${chalk.green("✓")} File ${chalk.cyan(options.path)} created successfully in storage ${chalk.cyan(options.storageId)}.`,
+        );
+      } else {
+        console.log(`${chalk.yellow("!")} Unexpected response from server: ${response.status}`);
+      }
+    } catch (error: any) {
+      if (error.response) {
+        console.error(
+          `${chalk.red("✗")} Failed to create file: ${chalk.yellow(error.response.data?.message || "Unknown error")}`,
+        );
+      } else if (error.request) {
+        console.error(`${chalk.red("✗")} No response received from server.`);
+      } else {
+        console.error(`${chalk.red("✗")} Error: ${error.message}`);
+      }
+    }
+  },
+};
diff --git a/src/commands/file/delete.ts b/src/commands/file/delete.ts
new file mode 100644
index 0000000..cbb143c
--- /dev/null
+++ b/src/commands/file/delete.ts
@@ -0,0 +1,42 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const fileDeleteDefinition = {
+  name: "delete",
+  description: "Delete a file from a storage.",
+  options: [
+    { name: "--storage-id <id>", description: "Storage ID", required: true },
+    { name: "--path <path>", description: "Remote file path", required: true },
+  ],
+  action: async (options: any) => {
+    const client = await getApiClient();
+
+    try {
+      const response = await client.delete(`/api/storage/${options.storageId}/files`, {
+        data: { path: options.path },
+      });
+
+      if (response.status === 200) {
+        console.log(
+          `${chalk.green("✓")} File ${chalk.cyan(options.path)} deleted from storage ${chalk.cyan(options.storageId)}.`,
+        );
+      } else {
+        console.log(`${chalk.yellow("!")} Unexpected response from server: ${response.status}`);
+      }
+    } catch (error: any) {
+      if (error.response) {
+        if (error.response.status === 404) {
+          console.error(`${chalk.red("✗")} File ${chalk.yellow(options.path)} not found.`);
+        } else {
+          console.error(
+            `${chalk.red("✗")} Failed to delete file: ${chalk.yellow(error.response.data?.message || "Unknown error")}`,
+          );
+        }
+      } else if (error.request) {
+        console.error(`${chalk.red("✗")} No response received from server.`);
+      } else {
+        console.error(`${chalk.red("✗")} Error: ${error.message}`);
+      }
+    }
+  },
+};
diff --git a/src/commands/file/list.ts b/src/commands/file/list.ts
new file mode 100644
index 0000000..3172c6b
--- /dev/null
+++ b/src/commands/file/list.ts
@@ -0,0 +1,49 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const fileListDefinition = {
+  name: "list",
+  description: "List files in a storage.",
+  options: [
+    { name: "--storage-id <id>", description: "Storage ID", required: true },
+    { name: "--prefix <prefix>", description: "Optional path prefix filter" },
+  ],
+  action: async (options: any) => {
+    const client = await getApiClient();
+
+    try {
+      const response = await client.get(`/api/storage/${options.storageId}/files`, {
+        params: options.prefix ? { prefix: options.prefix } : undefined,
+      });
+
+      if (response.status === 200 && response.data.data) {
+        const files = response.data.data;
+
+        if (!Array.isArray(files) || files.length === 0) {
+          console.log(`${chalk.yellow("!")} No files found.`);
+          return;
+        }
+
+        console.log(chalk.blue("Files:"));
+        files.forEach((file: any) => {
+          const path = file.path || file.name || "(unknown)";
+          console.log(`- ${chalk.cyan(path)}`);
+        });
+        console.log(`\n${chalk.green("✓")} Found ${chalk.bgGreen.black(` ${files.length} `)} files.`);
+      } else {
+        console.log(`${chalk.yellow("!")} Unexpected response from server.`);
+        console.log(`Status Code: ${chalk.blue(response.status)}`);
+      }
+    } catch (error: any) {
+      if (error.response) {
+        console.error(
+          `${chalk.red("✗")} Failed to list files: ${chalk.yellow(error.response.data?.message || "Unknown error")}`,
+        );
+      } else if (error.request) {
+        console.error(`${chalk.red("✗")} No response received from server.`);
+      } else {
+        console.error(`${chalk.red("✗")} Error: ${error.message}`);
+      }
+    }
+  },
+};
diff --git a/src/commands/file/overwrite.ts b/src/commands/file/overwrite.ts
new file mode 100644
index 0000000..cb1513a
--- /dev/null
+++ b/src/commands/file/overwrite.ts
@@ -0,0 +1,67 @@
+import chalk from "chalk";
+import fs from "fs/promises";
+import { getApiClient } from "../../api.js";
+
+export const fileOverwriteDefinition = {
+  name: "overwrite",
+  description: "Overwrite an existing file in a storage.",
+  options: [
+    { name: "--storage-id <id>", description: "Storage ID", required: true },
+    { name: "--path <path>", description: "Remote file path", required: true },
+    { name: "--content <content>", description: "Inline file content" },
+    { name: "--source <source>", description: "Local source file path" },
+  ],
+  action: async (options: any) => {
+    if (!options.content && !options.source) {
+      console.error(`${chalk.red("✗")} You must provide either --content or --source.`);
+      return;
+    }
+
+    if (options.content && options.source) {
+      console.error(`${chalk.red("✗")} Please provide only one of --content or --source.`);
+      return;
+    }
+
+    let content = options.content;
+    if (options.source) {
+      try {
+        content = await fs.readFile(options.source, "utf8");
+      } catch (error: any) {
+        console.error(`${chalk.red("✗")} Failed to read source file: ${chalk.yellow(error.message)}`);
+        return;
+      }
+    }
+
+    const client = await getApiClient();
+    const payload = {
+      path: options.path,
+      content,
+    };
+
+    try {
+      const response = await client.put(`/api/storage/${options.storageId}/files`, payload);
+
+      if (response.status === 200) {
+        console.log(
+          `${chalk.green("✓")} File ${chalk.cyan(options.path)} overwritten successfully in storage ${chalk.cyan(options.storageId)}.`,
+        );
+      } else {
+        console.log(`${chalk.yellow("!")} Unexpected response from server: ${response.status}`);
+      }
+    } catch (error: any) {
+      if (error.response) {
+        if (error.response.status === 404) {
+          console.error(`${chalk.red("✗")} File ${chalk.yellow(options.path)} not found.`);
+        } else {
+          console.error(
+            `${chalk.red("✗")} Failed to overwrite file: ${chalk.yellow(error.response.data?.message || "Unknown error")}`,
+          );
+        }
+      } else if (error.request) {
+        console.error(`${chalk.red("✗")} No response received from server.`);
+      } else {
+        console.error(`${chalk.red("✗")} Error: ${error.message}`);
+      }
+    }
+  },
+};
diff --git a/src/commands/get/function.ts b/src/commands/get/function.ts
new file mode 100644
index 0000000..6baf2ae
--- /dev/null
+++ b/src/commands/get/function.ts
@@ -0,0 +1,64 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const getFunctionDefinition = {
+  name: "function <id>",
+  description: "Get detailed information about a function by its ID.",
+  action: async (id: string) => {
+    await getFunction(id);
+  },
+};
+
+async function getFunction(id: string) {
+  const client = await getApiClient();
+
+  try {
+    const response = await client.get(`/api/function/${id}`);
+
+    if (response.status === 200 && response.data.data) {
+      const f = response.data.data;
+      
+      console.log(chalk.blue.bold(`\nFunction Details: ${f.name} (${f.id})`));
+      console.log(`${chalk.gray("-------------------------------------------")}`);
+      console.log(`${chalk.yellow("Name:")}        ${f.name}`);
+      console.log(`${chalk.yellow("ID:")}          ${f.id}`);
+      console.log(`${chalk.yellow("Description:")} ${f.description || chalk.gray("No description")}`);
+      console.log(`${chalk.yellow("Image:")}       ${f.image}`);
+      console.log(`${chalk.yellow("Startup File:")} ${f.startup_file}`);
+      
+      if (f.namespace) {
+        console.log(`${chalk.yellow("Namespace:")}    ${f.namespace.name} (${f.namespace.id})`);
+      }
+
+      if (f.executionAlias) {
+        console.log(`${chalk.yellow("Alias:")}        ${f.executionAlias}`);
+      }
+
+      console.log(`${chalk.gray("-------------------------------------------")}\n`);
+      
+    } else {
+      console.log(
+        `${chalk.yellow("!")} Unexpected response from server.`,
+      );
+      console.log(`Status Code: ${chalk.blue(response.status)}`);
+    }
+  } catch (error: any) {
+    if (error.response) {
+      if (error.response.status === 404) {
+        console.error(`${chalk.red("✗")} Function with ID ${chalk.yellow(id)} not found.`);
+      } else {
+        console.error(
+          `${chalk.red("✗")} Failed to fetch function details.`,
+        );
+        console.error(`Status Code: ${chalk.red(error.response.status)}`);
+        console.error(
+          `Message: ${chalk.yellow(error.response.data.message || "Unknown error from server")}`,
+        );
+      }
+    } else if (error.request) {
+      console.error(`${chalk.red("✗")} No response received from server.`);
+    } else {
+      console.error(`${chalk.red("✗")} Error:`, error.message);
+    }
+  }
+}
diff --git a/src/commands/get/namespace.ts b/src/commands/get/namespace.ts
new file mode 100644
index 0000000..57e757a
--- /dev/null
+++ b/src/commands/get/namespace.ts
@@ -0,0 +1,62 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const getNamespaceDefinition = {
+  name: "namespace <id>",
+  description: "Get detailed information about a namespace by its ID.",
+  action: async (id: string) => {
+    await getNamespace(id);
+  },
+};
+
+async function getNamespace(id: string) {
+  const client = await getApiClient();
+
+  try {
+    const response = await client.get(`/api/namespace/${id}`);
+
+    if (response.status === 200 && response.data.data) {
+      const ns = response.data.data;
+      
+      console.log(chalk.blue.bold(`\nNamespace Details: ${ns.name} (${ns.id})`));
+      console.log(`${chalk.gray("-------------------------------------------")}`);
+      console.log(`${chalk.yellow("Name:")} ${ns.name}`);
+      console.log(`${chalk.yellow("ID:")}   ${ns.id}`);
+      
+      if (ns.functions && ns.functions.length > 0) {
+        console.log(`${chalk.yellow("Functions:")}`);
+        ns.functions.forEach((f: any) => {
+          console.log(`- ${chalk.cyan(f.name)} ${chalk.gray(`(${f.id})`)}`);
+        });
+      } else {
+        console.log(`${chalk.yellow("Functions:")} ${chalk.gray("None")}`);
+      }
+
+      console.log(`${chalk.gray("-------------------------------------------")}\n`);
+      
+    } else {
+      console.log(
+        `${chalk.yellow("!")} Unexpected response from server.`,
+      );
+      console.log(`Status Code: ${chalk.blue(response.status)}`);
+    }
+  } catch (error: any) {
+    if (error.response) {
+      if (error.response.status === 404) {
+        console.error(`${chalk.red("✗")} Namespace with ID ${chalk.yellow(id)} not found.`);
+      } else {
+        console.error(
+          `${chalk.red("✗")} Failed to fetch namespace details.`,
+        );
+        console.error(`Status Code: ${chalk.red(error.response.status)}`);
+        console.error(
+          `Message: ${chalk.yellow(error.response.data.message || "Unknown error from server")}`,
+        );
+      }
+    } else if (error.request) {
+      console.error(`${chalk.red("✗")} No response received from server.`);
+    } else {
+      console.error(`${chalk.red("✗")} Error:`, error.message);
+    }
+  }
+}
diff --git a/src/commands/get/trigger.ts b/src/commands/get/trigger.ts
new file mode 100644
index 0000000..4d46337
--- /dev/null
+++ b/src/commands/get/trigger.ts
@@ -0,0 +1,65 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const getTriggerDefinition = {
+  name: "trigger <functionId> <triggerId>",
+  description: "Get detail of a specific trigger from a function.",
+  action: async (functionId: string, triggerId: string) => {
+    await getTrigger(functionId, triggerId);
+  },
+};
+
+async function getTrigger(functionId: string, triggerId: string) {
+  const client = await getApiClient();
+
+  try {
+    const response = await client.get(`/api/functions/${functionId}/triggers/${triggerId}`);
+
+    if (response.status === 200 && response.data.data) {
+      const t = response.data.data;
+      
+      console.log(chalk.blue.bold(`\nTrigger Details: ${t.name} (${t.id})`));
+      console.log(`${chalk.gray("-------------------------------------------")}`);
+      console.log(`${chalk.yellow("Name:")}        ${t.name}`);
+      console.log(`${chalk.yellow("ID:")}          ${t.id}`);
+      console.log(`${chalk.yellow("Description:")} ${t.description || chalk.gray("No description")}`);
+      console.log(`${chalk.yellow("Cron:")}        ${chalk.cyan(t.cron)}`);
+      console.log(`${chalk.yellow("Enabled:")}     ${t.enabled ? chalk.green("Yes") : chalk.red("No")}`);
+      console.log(`${chalk.yellow("Function ID:")} ${t.functionId}`);
+      
+      if (t.nextRun) {
+        console.log(`${chalk.yellow("Next Run:")}    ${new Date(t.nextRun).toLocaleString()}`);
+      }
+      
+      if (t.data) {
+        console.log(`${chalk.yellow("Data:")}        ${t.data}`);
+      }
+
+      console.log(`${chalk.gray("-------------------------------------------")}\n`);
+      
+    } else {
+      console.log(
+        `${chalk.yellow("!")} Unexpected response from server.`,
+      );
+      console.log(`Status Code: ${chalk.blue(response.status)}`);
+    }
+  } catch (error: any) {
+    if (error.response) {
+      if (error.response.status === 404) {
+        console.error(`${chalk.red("✗")} Trigger or function not found.`);
+      } else {
+        console.error(
+          `${chalk.red("✗")} Failed to fetch trigger details.`,
+        );
+        console.error(`Status Code: ${chalk.red(error.response.status)}`);
+        console.error(
+          `Message: ${chalk.yellow(error.response.data.message || "Unknown error from server")}`,
+        );
+      }
+    } else if (error.request) {
+      console.error(`${chalk.red("✗")} No response received from server.`);
+    } else {
+      console.error(`${chalk.red("✗")} Error:`, error.message);
+    }
+  }
+}
diff --git a/src/commands/update/function.ts b/src/commands/update/function.ts
new file mode 100644
index 0000000..3f3400c
--- /dev/null
+++ b/src/commands/update/function.ts
@@ -0,0 +1,76 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const updateFunctionDefinition = {
+  name: "function <id>",
+  description: "Update an existing serverless function.",
+  options: [
+    { name: "--name <name>", description: "Function name" },
+    { name: "--description <description>", description: "Function description" },
+    { name: "--startup-file <file>", description: "Startup file name" },
+    { name: "--execution-alias <alias>", description: "Custom execution alias" },
+    { name: "--docker-mount", description: "Enable Docker mount", type: "boolean" },
+    { name: "--ffmpeg-install", description: "Install ffmpeg in container", type: "boolean" },
+    { name: "--imported", description: "Marks the function as imported", type: "boolean" },
+    { name: "--cache-enabled <enabled>", description: "Enable response caching (true/false)" },
+    { name: "--cache-ttl <seconds>", description: "Cache TTL in seconds" },
+  ],
+  action: async (id: string, options: any) => {
+    let parsedCacheEnabled: boolean | undefined;
+    if (options.cacheEnabled !== undefined) {
+      const normalized = String(options.cacheEnabled).toLowerCase();
+      if (normalized !== "true" && normalized !== "false") {
+        console.error(`${chalk.red("✗")} Invalid value for --cache-enabled. Use true or false.`);
+        return;
+      }
+      parsedCacheEnabled = normalized === "true";
+    }
+
+    const parsedCacheTtl = options.cacheTtl !== undefined ? Number(options.cacheTtl) : undefined;
+    if (parsedCacheTtl !== undefined && Number.isNaN(parsedCacheTtl)) {
+      console.error(`${chalk.red("✗")} Invalid value for --cache-ttl. Please provide a number.`);
+      return;
+    }
+
+    const data: Record<string, any> = {};
+
+    if (options.name !== undefined) data.name = options.name;
+    if (options.description !== undefined) data.description = options.description;
+    if (options.startupFile !== undefined) data.startup_file = options.startupFile;
+    if (options.executionAlias !== undefined) data.executionAlias = options.executionAlias;
+    if (options.dockerMount) data.docker_mount = true;
+    if (options.ffmpegInstall) data.ffmpeg_install = true;
+    if (options.imported) data.imported = true;
+    if (parsedCacheEnabled !== undefined) data.cache_enabled = parsedCacheEnabled;
+    if (parsedCacheTtl !== undefined) data.cache_ttl = parsedCacheTtl;
+
+    if (Object.keys(data).length === 0) {
+      console.error(`${chalk.red("✗")} No update fields provided. Use --help to see available options.`);
+      return;
+    }
+
+    const client = await getApiClient();
+
+    try {
+      const response = await client.patch(`/api/function/${id}`, data);
+
+      if (response.status === 200) {
+        console.log(`${chalk.green("✓")} Function with ID ${chalk.cyan(id)} updated successfully.`);
+      } else {
+        console.log(`${chalk.yellow("!")} Unexpected response from server: ${response.status}`);
+      }
+    } catch (error: any) {
+      if (error.response) {
+        if (error.response.status === 404) {
+          console.error(`${chalk.red("✗")} Function with ID ${chalk.yellow(id)} not found.`);
+        } else {
+          console.error(
+            `${chalk.red("✗")} Failed to update function: ${chalk.yellow(error.response.data.message || "Unknown error")}`,
+          );
+        }
+      } else {
+        console.error(`${chalk.red("✗")} Error: ${error.message}`);
+      }
+    }
+  },
+};
diff --git a/src/commands/update/namespace.ts b/src/commands/update/namespace.ts
new file mode 100644
index 0000000..e6e0b24
--- /dev/null
+++ b/src/commands/update/namespace.ts
@@ -0,0 +1,48 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const updateNamespaceDefinition = {
+  name: "namespace <id>",
+  description: "Update an existing namespace.",
+  options: [
+    { name: "--name <name>", description: "Namespace name" },
+    { name: "--description <description>", description: "Namespace description" },
+  ],
+  action: async (id: string, options: any) => {
+    const data: Record<string, any> = {};
+
+    if (options.name !== undefined) data.name = options.name;
+    if (options.description !== undefined) data.description = options.description;
+
+    if (Object.keys(data).length === 0) {
+      console.error(`${chalk.red("✗")} No update fields provided. Use --help to see available options.`);
+      return;
+    }
+
+    const client = await getApiClient();
+
+    try {
+      const response = await client.patch(`/api/namespace/${id}`, data);
+
+      if (response.status === 200) {
+        console.log(`${chalk.green("✓")} Namespace with ID ${chalk.cyan(id)} updated successfully.`);
+      } else {
+        console.log(`${chalk.yellow("!")} Unexpected response from server: ${response.status}`);
+      }
+    } catch (error: any) {
+      if (error.response) {
+        if (error.response.status === 404) {
+          console.error(`${chalk.red("✗")} Namespace with ID ${chalk.yellow(id)} not found.`);
+        } else {
+          console.error(
+            `${chalk.red("✗")} Failed to update namespace: ${chalk.yellow(error.response.data.message || "Unknown error")}`,
+          );
+        }
+      } else if (error.request) {
+        console.error(`${chalk.red("✗")} No response received from server.`);
+      } else {
+        console.error(`${chalk.red("✗")} Error: ${error.message}`);
+      }
+    }
+  },
+};
diff --git a/src/commands/update/trigger.ts b/src/commands/update/trigger.ts
new file mode 100644
index 0000000..f51678d
--- /dev/null
+++ b/src/commands/update/trigger.ts
@@ -0,0 +1,66 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const updateTriggerDefinition = {
+  name: "trigger <functionId> <triggerId>",
+  description: "Update an existing trigger for a function.",
+  options: [
+    { name: "--name <name>", description: "Trigger name" },
+    { name: "--description <description>", description: "Trigger description" },
+    { name: "--cron <cron>", description: "Cron expression" },
+    { name: "--enabled <enabled>", description: "Whether the trigger is enabled (true/false)" },
+    { name: "--data <data>", description: "Optional trigger payload data" },
+  ],
+  action: async (functionId: string, triggerId: string, options: any) => {
+    let parsedEnabled: boolean | undefined;
+    if (options.enabled !== undefined) {
+      const normalized = String(options.enabled).toLowerCase();
+      if (normalized !== "true" && normalized !== "false") {
+        console.error(`${chalk.red("✗")} Invalid value for --enabled. Use true or false.`);
+        return;
+      }
+      parsedEnabled = normalized === "true";
+    }
+
+    const data: Record<string, any> = {};
+
+    if (options.name !== undefined) data.name = options.name;
+    if (options.description !== undefined) data.description = options.description;
+    if (options.cron !== undefined) data.cron = options.cron;
+    if (parsedEnabled !== undefined) data.enabled = parsedEnabled;
+    if (options.data !== undefined) data.data = options.data;
+
+    if (Object.keys(data).length === 0) {
+      console.error(`${chalk.red("✗")} No update fields provided. Use --help to see available options.`);
+      return;
+    }
+
+    const client = await getApiClient();
+
+    try {
+      const response = await client.patch(`/api/functions/${functionId}/triggers/${triggerId}`, data);
+
+      if (response.status === 200) {
+        console.log(
+          `${chalk.green("✓")} Trigger with ID ${chalk.cyan(triggerId)} for function ${chalk.cyan(functionId)} updated successfully.`,
+        );
+      } else {
+        console.log(`${chalk.yellow("!")} Unexpected response from server: ${response.status}`);
+      }
+    } catch (error: any) {
+      if (error.response) {
+        if (error.response.status === 404) {
+          console.error(`${chalk.red("✗")} Trigger or function not found.`);
+        } else {
+          console.error(
+            `${chalk.red("✗")} Failed to update trigger: ${chalk.yellow(error.response.data.message || "Unknown error")}`,
+          );
+        }
+      } else if (error.request) {
+        console.error(`${chalk.red("✗")} No response received from server.`);
+      } else {
+        console.error(`${chalk.red("✗")} Error: ${error.message}`);
+      }
+    }
+  },
+};