feat(cors): implement CORS management commands and utilities

Added coding docs from shsf to shsf-cli
bump version
2026-04-14 22:38:27 +02:00 · 2026-04-14 18:23:11 +02:00 · 2026-04-14 18:13:35 +02:00 · 2026-04-14 18:11:13 +02:00 · 2026-04-14 17:55:09 +02:00 · 2026-04-05 17:50:59 +02:00
61 changed files with 3474 additions and 14 deletions
@@ -24,3 +24,6 @@
 - **New Commands**: To add a command, create a new file in `src/commands/` (or a subfolder). It must export a definition object (default or named) with `name`, `description`, and `action`.
 - **Error Handling**: Follow the pattern in [src/commands/health.ts](src/commands/health.ts) for handling Axios errors (check for `error.response`, `error.request`, etc.).
 - **No Global Scope**: Keep command logic within the `action` function or extracted to utility modules to maintain testability.
+
+## Versioning
+- **Versioning**: Always increment the version number in package.json whenever a change is merged into main. The version format is major.minor.patch.
@@ -4,9 +4,15 @@ on:
  push:
    branches:
      - '**'
+    paths:
+      - '**/*.ts'
+      - '**/*.json'
  pull_request:
    branches:
      - main
+    paths:
+      - '**/*.ts'
+      - '**/*.json'

 jobs:
  build:
@@ -22,6 +28,7 @@ jobs:
          node-version: '24'

      - run: pnpm install --no-frozen-lockfile
+      - run: pnpm test
      - run: pnpm build

      - name: Zip dist directory
@@ -74,12 +81,18 @@ jobs:
        with:
          name: dist-artifact

+      - name: Get version from package.json
+        id: package_version
+        run: |
+          pkg_version=$(node -p "require('./package.json').version")
+          echo "VERSION=$pkg_version" >> $GITHUB_OUTPUT
+
      - name: Create Release
        uses: softprops/action-gh-release@v2
        with:
          files: dist.zip
-          tag_name: v${{ github.run_number }}
-          name: Release v${{ github.run_number }}
+          tag_name: v${{ steps.package_version.outputs.VERSION }}
+          name: Release v${{ steps.package_version.outputs.VERSION }}
          draft: false
          prerelease: false
        env:
@@ -1,4 +1,6 @@
 node_modules
 dist
 build
-pnpm-lock.yaml
+pnpm-lock.yaml
+testing
+.codex
@@ -0,0 +1,389 @@
+---
+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
+- `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 function execute --id <id> [--payload <json>] [--no-stream]`: Execute a function and stream the output (debug/internal).
+
+- `shsf storage create --name <name> --purpose <purpose>`: Create a new storage.
+- `shsf storage delete --name <name>`: Delete a storage.
+- `shsf storage list`: List all storages.
+- `shsf storage get-items --name <name>`: List all items in a storage.
+- `shsf storage set-item --name <name> --key <key> --value <value> [--expires <expires>]`: Set a storage item (value can be JSON).
+- `shsf storage delete-item --name <name> --key <key>`: Delete a storage item.
+- `shsf storage clear-items --name <name>`: Clear all items from a storage.
+
+- `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/update a file in a function. (use `shsf file create -h` first)
+- `shsf file list`: List files in a function. (use `shsf file list -h` first)
+- `shsf file rename`: Rename a file in a function. (use `shsf file rename -h` first)
+- `shsf file delete`: Delete a file from a function. (use `shsf file delete -h` first)
+
+- `shsf env add --id <id> --name <name> --value <value>`: Adds or updates an environment variable for a function.
+- `shsf env remove --id <id> --name <name>`: Removes a specific environment variable from a function.
+- `shsf env list --id <id>`: Lists all environment variables for a function.
+- `shsf env flush --id <id>`: Removes ALL environment variables from a function.
+
+- `shsf remote pull --id <id> --into <path> [--force]`: Pull files from a function into a local directory.
+- `shsf remote push --id <id> --from <path> [--force]`: Push files from a local directory to a function.
+
+- `shsf req add <package> --id <functionid>`: Add a package to the requirements.txt of a function.
+- `shsf req remove <package> --id <functionid>`: Remove a package from the requirements.txt of a function.
+
+
+### Ignore & Mapping files
+
+`shsf remote push` supports a `.shsfignore` file (gitignore-like) placed in the source directory or repository root. Lines are treated like gitignore patterns and will prevent matching files from being pushed.
+
+You can also create a `.shsf.json` mapping file in the repository root so you don't need to pass `--id` and `--from` every time. Example `.shsf.json`:
+
+```json
+{
+	"default": {
+		"id": "my-function-id",
+		"from": "src/functions/my-fn"
+	}
+}
+```
+
+Command-line flags take precedence over values in `.shsf.json`.
+
+## 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.
+
+## Ui Links
+Get the ui url with:
+```bash
+shsf uiurl
+```
+
+### Example
+After creating a function and receiving an ID (for example, 81), you can share the following URL with your human so they can view the function in the UI:
+```
+[UI_URL]/functions/[ID]
+```
+
+## Update
+Update with your package manager of choice. ALWAYS pnpm:
+```bash
+pnpm add -g shsf-cli
+```
+Note that new features are often released and a user might tell you to do things that are only in the latest version. So its a good idea to always keep it updated.
+
+It is also good practice to update this skill every now and then, as it might get new features that are not documented here yet.
+Download the latest version with:
+```
+curl https://raw.githubusercontent.com/Space-Banane/shsf-cli/refs/heads/main/OpenclawSkill.md > /tmp/OpenclawSkill.md
+```
+and then replace the old one with the new one using `mv`.
+
+## Missing a feature?
+Features might be not documented yet, as this skill document rarely updates.
+Use the shsf -h command to see options and features.
+
+CODING DOC:
+# SHSF Platform Reference (Agent-Optimized)
+
+## Critical Rules (check before writing any code)
+
+- Python files use `.py`, Go files use `.go` — never mix runtimes
+- Go package must be `main`; entry-point must be `main_user()`, never `main()`
+- Python entry-point must be `def main(args):`
+- **Always** `import json` and call `json.loads(args.get("body", "{}"))` before accessing body fields in Python
+- Forbidden filenames: `_runner.py`, `_runner.js`, `init.sh`
+- Filenames must never contain `/` or `\` — no subdirectories
+- Never hard-code secrets — use environment variables via `os.getenv()`
+- Never invent SHSF APIs not documented here
+- Never write partial files or placeholder comments
+- Only create `requirements.txt` / `go.mod` if dependencies are actually needed
+
+---
+
+## Entry Points
+
+### Python
+```python
+def main(args):
+    return {"hello": "world"}  # plain dict → 200 JSON
+```
+
+### Go
+```go
+package main
+
+func main_user(args interface{}) (interface{}, error) {
+    return map[string]string{"hello": "world"}, nil
+}
+```
+
+---
+
+## The `args` Object
+
+| Field      | Type       | Notes                                                                 |
+|------------|------------|-----------------------------------------------------------------------|
+| `body`     | string     | Raw JSON string — **must** be parsed with `json.loads()` before use  |
+| `queries`  | dict / map | URL query parameters                                                  |
+| `route`    | string     | Sub-path segment after function URL. Default: `"default"`            |
+| `headers`  | dict / map | Lowercased HTTP request headers                                       |
+| `raw_body` | bytes      | Raw request body (file uploads, binary data)                          |
+| `method`   | string     | HTTP method (GET, POST, …)                                            |
+
+Always use `.get()` / nil-checks — never assume a field is present.
+
+### Python args example
+```python
+import json
+
+def main(args):
+    body    = json.loads(args.get("body", "{}"))   # always parse first
+    queries = args.get("queries", {})
+    route   = args.get("route", "default")
+    name    = body.get("name", "stranger")
+    page    = queries.get("page", "1")
+    return {"greeting": f"Hello {name}", "page": page, "route": route}
+```
+
+---
+
+## Response Formats
+
+### Simple 200 JSON (plain dict)
+```python
+return {"key": "value"}
+```
+
+### v2 Envelope (control status, headers, body)
+```python
+return {
+    "_shsf":    "v2",
+    "_code":    201,                                         # HTTP status code
+    "_headers": {"Content-Type": "application/json"},       # optional
+    "_res":     {"created": True, "id": 42}                 # response body
+}
+```
+
+### Error response
+```python
+return {"_shsf": "v2", "_code": 400, "_res": {"error": "missing field 'name'"}}
+```
+
+### Redirect (301 / 302)
+```python
+return {"_shsf": "v2", "_code": 302, "_location": "https://example.com/target"}
+```
+
+### HTML response
+```python
+def main(args):
+    with open("index.html", "r") as f:
+        html = f.read()
+    return {"_shsf": "v2", "_code": 200, "_headers": {"Content-Type": "text/html"}, "_res": html}
+```
+
+> **Static HTML shortcut**: if the only file is a single `.html` set as the startup file, SHSF serves it directly without spinning up a runtime.
+
+---
+
+## Routing
+
+`args["route"]` holds the single URL segment after the function base URL (no leading slash, default `"default"`). Only **one** segment is supported.
+
+```python
+def main(args):
+    route = args.get("route", "default")
+    if route == "register":   return handle_register(args)
+    elif route == "login":    return handle_login(args)
+    elif route == "status":   return {"status": "ok"}
+    else:                     return {"_shsf": "v2", "_code": 404, "_res": {"error": "route not found"}}
+```
+
+---
+
+## Environment Variables
+
+Never hard-code secrets. Define them in the SHSF dashboard.
+
+```python
+import os
+
+def main(args):
+    api_key = os.getenv("MY_API_KEY", "")
+    if not api_key:
+        return {"_shsf": "v2", "_code": 500, "_res": {"error": "MY_API_KEY not set"}}
+    return {"ok": True}
+```
+
+Go: `apiKey := os.Getenv("MY_API_KEY")`
+
+---
+
+## Persistent Storage
+
+| Path    | Persistence              | Use for                         |
+|---------|--------------------------|---------------------------------|
+| `/app/` | Persists across calls    | Cache, state files              |
+| `/tmp/` | Wiped on container restart | Truly temporary scratch work  |
+
+**WARNING**: SHSF may restart or update containers, which recreates all of it, even the `/app/` directory. For critical data, use `_db_com` instead.
+
+```python
+import json, os
+
+CACHE = "/app/cache.json"
+
+def main(args):
+    data = json.load(open(CACHE)) if os.path.exists(CACHE) else {}
+    data["hits"] = data.get("hits", 0) + 1
+    json.dump(data, open(CACHE, "w"))
+    return {"hits": data["hits"]}
+```
+
+### Redis (shared key-value, fast)
+```python
+import redis
+
+r = redis.Redis(host="localhost", port=6379, db=0)
+
+def main(args):
+    r.incr("counter")
+    return {"counter": int(r.get("counter"))}
+```
+
+---
+
+## Database (`_db_com`) — Python
+
+`_db_com.py` is auto-provisioned. Add `requests` to `requirements.txt`.
+
+```python
+from _db_com import database
+from datetime import datetime, timedelta
+
+db = database()
+
+def main(args):
+    db.create_storage("my_app", purpose="application data")  # idempotent, safe every call
+
+    db.set("my_app", "username", "alice")                    # write
+
+    expires = (datetime.utcnow() + timedelta(hours=1)).isoformat()
+    db.set("my_app", "session", "tok_abc", expires_at=expires)  # write with TTL
+
+    username = db.get("my_app", "username")                  # read (None if missing)
+    exists   = db.exists("my_app", "username")               # existence check
+    items    = db.list_items("my_app")                       # list all keys
+    db.delete_item("my_app", "username")                     # delete
+
+    return {"username": username, "items": items}
+```
+
+### Go `dbcom`
+```go
+package main
+
+import "myfunction/dbcom"
+
+func main_user(args interface{}) (interface{}, error) {
+    db := dbcom.New()
+    if _, err := db.Set("my-storage", "key", "value", nil); err != nil {
+        return nil, err
+    }
+    value, err := db.Get("my-storage", "key")
+    if err != nil {
+        return nil, err
+    }
+    return map[string]interface{}{"value": value}, nil
+}
+```
+
+---
+
+## File Uploads / Raw Body
+
+```python
+def main(args):
+    raw = args.get("raw_body")
+    if raw is None:
+        return {"_shsf": "v2", "_code": 400, "_res": {"error": "no body provided"}}
+    if isinstance(raw, str):
+        raw = raw.encode("latin-1")
+    with open("/app/upload.bin", "wb") as f:
+        f.write(raw)
+    return {"_shsf": "v2", "_code": 200, "_res": {"saved": True}}
+```
+
+---
+
+## Secure Header (`x-secure-header`)
+
+When the secure-header feature is enabled, SHSF validates the token **before** invoking your function — no need to re-validate. Read it only for logging:
+
+```python
+def main(args):
+    token = args.get("headers", {}).get("x-secure-header", "")
+    return {"authenticated": True, "token_preview": token[:4] + "…"}
+```
+
+---
+
+## Dependency Files
+
+| Runtime | File              | Notes                                          |
+|---------|-------------------|------------------------------------------------|
+| Python  | `requirements.txt`| pip-installed before first run                 |
+| Go      | `go.mod`+`go.sum` | Module deps, auto-downloaded                   |
+
+Only create these files if you have actual dependencies.
+
+### Python `requirements.txt`
+```
+requests==2.31.0
+beautifulsoup4==4.12.2
+```
+
+### Go `go.mod`
+```
+module myfunction
+
+go 1.23
+
+require (
+    github.com/google/uuid v1.3.0
+)
+```
+
+Supported Go versions: `1.20`, `1.21`, `1.22`, `1.23`
@@ -5,7 +5,6 @@ A powerful command-line interface for managing and interacting with your SHSF in
 [![pnpm](https://img.shields.io/badge/maintained%20with-pnpm-cc3534.svg)](https://pnpm.io/)
 [![TypeScript](https://img.shields.io/badge/built%20with-TypeScript-blue.svg)](https://www.typescriptlang.org/)

-
 ## 🚦 Getting Started

 ### 📋 Prerequisites
@@ -20,10 +19,13 @@ To install **SHSF CLI** globally on your system:
 ```bash
 pnpm add -g shsf-cli
 ```
-or 
+
+or
+
 ```bash
 npm install -g shsf-cli
 ```
+
 ---

 Once installed, simply type:
@@ -31,22 +33,25 @@ Once installed, simply type:
 ```bash
 shsf health
 ```
-and it will ask you for your SHSF instance URL and API token to perform a health check.

+and it will ask you for your SHSF instance URL and API token to perform a health check.

 ## 🛠️ Usage & Commands

 ### 🩺 Health Check
+
 Quickly see if the system is up and running:
+
 ```bash
 shsf health
 ```

-
 ### 🏗️ Local Development
+
 If you're contributing or running from source:

 1. **Setup**:
+
   ```bash
   git clone https://github.com/Space-Banane/shsf-cli.git
   cd shsf-cli
@@ -59,6 +64,31 @@ If you're contributing or running from source:
   pnpm start [cmd] # Run a command directly
   ```

+## Ignore & Mapping files
+
+You can control what files `shsf remote push` ignores using a `.shsfignore` file (gitignore-style).
+
+Place `.shsfignore` in the source directory you're pushing or in the repository root. Examples:
+
+```
+# ignore logs and secrets
+*.log
+secret.txt
+node_modules
+```
+
+You can also create a `.shsf.json` mapping file at the repository root to avoid passing `--id` and `--from` every time. Example:
+
+```json
+{
+  "default": {
+    "id": "my-function-id",
+    "from": "src/functions/my-fn"
+  }
+}
+```
+
+Command-line options always override values from `.shsf.json`.

 ## 🤝 Contributing

@@ -80,4 +110,3 @@ We love builders! To add a new command:
 ## 📄 License

 Licensed under the **MIT-0 License**. Happy coding! 🍌
-
@@ -1,6 +1,6 @@
 {
  "name": "shsf-cli",
-  "version": "2.0.1",
+  "version": "2.3.0",
  "description": "",
  "type": "module",
  "files": [
@@ -12,7 +12,9 @@
  "scripts": {
    "build": "rimraf dist && tsc",
    "start": "node dist/index.js",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
  },
  "keywords": [],
  "author": "",
@@ -21,9 +23,11 @@
  "devDependencies": {
    "@types/inquirer": "^9.0.9",
    "@types/node": "^25.5.0",
+    "@vitest/coverage-v8": "^4.1.0",
    "rimraf": "^6.1.3",
    "ts-node": "^10.9.2",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.0"
  },
  "dependencies": {
    "axios": "^1.13.6",
@@ -0,0 +1,52 @@
+import { describe, it, expect, vi } from 'vitest';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+describe('Command Loading', () => {
+  it('all command files should export a valid definition', async () => {
+    const commandsDir = path.resolve(__dirname, '../commands');
+    
+    function getCommandFiles(dir: string): string[] {
+      const files = fs.readdirSync(dir);
+      let commandFiles: string[] = [];
+
+      for (const file of files) {
+        const fullPath = path.join(dir, file);
+        if (fs.statSync(fullPath).isDirectory()) {
+          commandFiles = commandFiles.concat(getCommandFiles(fullPath));
+        } else if (file.endsWith('.ts') || file.endsWith('.js')) {
+          commandFiles.push(fullPath);
+        }
+      }
+
+      return commandFiles;
+    }
+
+    const files = getCommandFiles(commandsDir);
+    expect(files.length).toBeGreaterThan(0);
+
+    for (const file of files) {
+      // Use dynamic import to check the module
+      // We convert absolute path to file:// URL for ESM import on Linux/Windows
+      const module = await import(`file://${file}`);
+      
+      const definition = module.default || Object.values(module).find((val: any) => 
+        val && typeof val === 'object' && val.name && typeof val.action === 'function'
+      );
+
+      if (!definition) {
+        throw new Error(`Command file ${file} does not export a valid command definition (needs name and action function)`);
+      }
+
+      expect(definition).toBeDefined();
+      expect(typeof definition.name).toBe('string');
+      expect(typeof definition.action).toBe('function');
+      
+      console.log(`✓ Validated command: ${definition.name} (${path.relative(commandsDir, file)})`);
+    }
+  }, 20000);
+});
@@ -0,0 +1,11 @@
+import { describe, it, expect, vi } from 'vitest';
+import path from 'path';
+import os from 'os';
+import { getConfigPath } from '../config.js';
+
+describe('config', () => {
+  it('should return the correct config path', () => {
+    const expectedPath = path.join(os.homedir(), '.shsf_config');
+    expect(getConfigPath()).toBe(expectedPath);
+  });
+});
@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import { parseCorsOriginsOption } from "../utils/cors.js";
+
+describe("parseCorsOriginsOption", () => {
+  it("returns undefined when no value is provided", () => {
+    expect(parseCorsOriginsOption(undefined)).toEqual({});
+  });
+
+  it("parses, normalizes, and deduplicates URLs", () => {
+    const parsed = parseCorsOriginsOption([
+      "https://example.com",
+      "https://example.com/path",
+      "http://localhost:3000,http://localhost:3000/",
+    ]);
+
+    expect(parsed).toEqual({
+      corsOrigins: ["https://example.com", "http://localhost:3000"],
+    });
+  });
+
+  it("returns an error for invalid URLs", () => {
+    const parsed = parseCorsOriginsOption(["not-a-url"]);
+    expect(parsed.error).toMatch("Invalid CORS origin URL");
+  });
+
+  it("returns an error for unsupported protocols", () => {
+    const parsed = parseCorsOriginsOption(["ftp://example.com"]);
+    expect(parsed.error).toMatch("Only http and https are allowed");
+  });
+});
@@ -0,0 +1,47 @@
+import { describe, it, expect } from "vitest";
+import {
+  listFiles,
+  createOrUpdateFile,
+  deleteFile,
+  renameFile,
+} from "../utils/fileops.js";
+
+function makeClient(overrides: any = {}) {
+  return {
+    get: async (u: string) => ({ status: 200, data: { data: overrides.getData || [] } }),
+    put: async (u: string, p: any) => ({ status: overrides.putStatus || 200, data: { ok: true } }),
+    delete: async (u: string, opts: any) => ({ status: overrides.deleteStatus || 200, data: {} }),
+    patch: async (u: string, p: any) => ({ status: overrides.patchStatus || 200, data: {} }),
+  };
+}
+
+describe("fileops", () => {
+  it("lists files", async () => {
+    const client = makeClient({ getData: [{ id: "1", name: "a.txt" }] });
+    const files = await listFiles(client, "fn1");
+    expect(files).toHaveLength(1);
+    const file = files[0];
+    expect(file).toHaveProperty("id");
+    expect(file.id).toBe("1");
+    // Accept either `name` or `filename` depending on API shape
+    expect(file.name || file.filename).toBe("a.txt");
+  });
+
+  it("creates or updates a file", async () => {
+    const client = makeClient({ putStatus: 201 });
+    const res = await createOrUpdateFile(client, "fn1", "a.txt", "hello");
+    expect(res).toBeDefined();
+  });
+
+  it("deletes a file", async () => {
+    const client = makeClient({ deleteStatus: 200 });
+    const ok = await deleteFile(client, "fn1", "file1");
+    expect(ok).toBe(true);
+  });
+
+  it("renames a file", async () => {
+    const client = makeClient({ patchStatus: 200 });
+    const res = await renameFile(client, "fn1", "file1", "b.txt");
+    expect(res).toBeDefined();
+  });
+});
@@ -0,0 +1,73 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { readIgnoreFile, matchesAnyPattern, readMappingFile, defaultUnpushableFiles } from '../utils/push_helpers.js';
+
+const tmpDirs: string[] = [];
+
+afterEach(() => {
+  for (const d of tmpDirs) {
+    try {
+      fs.rmSync(d, { recursive: true, force: true });
+    } catch (_e) {
+      // ignore cleanup errors
+    }
+  }
+  tmpDirs.length = 0;
+});
+
+describe('push_helpers', () => {
+  it('readIgnoreFile should read patterns from provided dir', () => {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'shsf-test-'));
+    tmpDirs.push(tmp);
+    const ignorePath = path.join(tmp, '.shsfignore');
+    fs.writeFileSync(ignorePath, '# comment\nsecret.txt\n*.log\n');
+
+    const patterns = readIgnoreFile(tmp);
+    expect(patterns).toContain('secret.txt');
+    expect(patterns).toContain('*.log');
+  });
+
+  it('matchesAnyPattern should match suffix and glob patterns', () => {
+    const patterns = ['.secret', '*.log', 'dockerfile'];
+    expect(matchesAnyPattern('foo.secret', patterns)).toBe(true);
+    expect(matchesAnyPattern('bar.log', patterns)).toBe(true);
+    expect(matchesAnyPattern('Dockerfile', patterns)).toBe(true);
+    expect(matchesAnyPattern('notmatched.txt', patterns)).toBe(false);
+  });
+
+  it('defaultUnpushableFiles contains common suffix', () => {
+    expect(defaultUnpushableFiles).toContain('.png');
+  });
+
+  it('readMappingFile should read mapping from cwd when present', () => {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'shsf-map-'));
+    tmpDirs.push(tmp);
+    const mapPath = path.join(tmp, '.shsf.json');
+    fs.writeFileSync(mapPath, JSON.stringify({ default: { id: 'abc', from: 'src' } }));
+
+    const mapping = readMappingFile(tmp);
+    expect(mapping).toBeTruthy();
+    expect(mapping?.id).toBe('abc');
+    expect(mapping?.from).toBe('src');
+  });
+
+  it('readMappingFile should return null when file is missing', () => {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'shsf-map-missing-'));
+    tmpDirs.push(tmp);
+
+    const mapping = readMappingFile(tmp);
+    expect(mapping).toBeNull();
+  });
+
+  it('readMappingFile should return null for malformed json', () => {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'shsf-map-bad-'));
+    tmpDirs.push(tmp);
+    const mapPath = path.join(tmp, '.shsf.json');
+    fs.writeFileSync(mapPath, '{ this is : not valid json }');
+
+    const mapping = readMappingFile(tmp);
+    expect(mapping).toBeNull();
+  });
+});
@@ -0,0 +1,44 @@
+import { describe, it, expect } from 'vitest';
+import { readFileSync, readdirSync, statSync } from 'fs';
+import path from 'path';
+
+function getFilesRecursively(dir: string): string[] {
+  let files: string[] = [];
+  const items = readdirSync(dir);
+  for (const item of items) {
+    const fullPath = path.join(dir, item);
+    if (statSync(fullPath).isDirectory()) {
+      if (item !== '__tests__') {
+        files = files.concat(getFilesRecursively(fullPath));
+      }
+    } else if (item.endsWith('.ts')) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+describe('API URL validation', () => {
+  it('should ensure all API client calls start with /api/', () => {
+    const tsFiles = getFilesRecursively('src');
+    const violations: string[] = [];
+
+    // Regex to match common patterns like client.get('/path') or client.post(`/path`)
+    // specifically looking for paths that start with / but NOT /api/ or /health
+    const urlPattern = /client\.(get|post|put|delete|patch)\(['"`]\/(?!(api|health)\/)[^'"`]+['"`]/g;
+
+    tsFiles.forEach(file => {
+      const content = readFileSync(file, 'utf-8');
+      let match;
+      while ((match = urlPattern.exec(content)) !== null) {
+        // Double check for exact /health match (without trailing slash)
+        if (match[0].includes("'/health'") || match[0].includes('"/health"') || match[0].includes('`/health`')) {
+          continue;
+        }
+        violations.push(`${file}: ${match[0]}`);
+      }
+    });
+
+    expect(violations, `Found API calls not starting with /api/:\n${violations.join('\n')}`).toHaveLength(0);
+  });
+});
@@ -55,10 +55,21 @@ export async function resolveCommands() {
    const definition = module.default || Object.values(module).find((val: any) => val && val.name && val.action);

    if (definition && definition.name && definition.action) {
-      currentParent
+      const command = currentParent
        .command(definition.name)
-        .description(definition.description || '')
-        .action(definition.action);
+        .description(definition.description || '');
+
+      if (definition.options) {
+        definition.options.forEach((opt: any) => {
+          if (opt.required) {
+            command.requiredOption(opt.name, opt.description);
+          } else {
+            command.option(opt.name, opt.description);
+          }
+        });
+      }
+
+      command.action(definition.action);
    }
  }
 }
@@ -0,0 +1,41 @@
+import chalk from "chalk";
+import {
+  getFunctionCorsOrigins,
+  handleCorsCommandError,
+  resolveFunctionId,
+  setFunctionCorsOrigins,
+  validateSingleOrigin,
+} from "../../utils/cors_commands.js";
+
+export const addCorsDefinition = {
+  name: "add <origin>",
+  description: "Add a CORS allowlist origin (must start with http:// or https://).",
+  options: [{ name: "--id <id>", description: "Function ID (falls back to .shsf.json default id)" }],
+  action: async (origin: string, options: { id?: string }) => {
+    const functionId = resolveFunctionId(options);
+    if (!functionId) return;
+
+    const validated = validateSingleOrigin(origin);
+    if (validated.error) {
+      console.error(`${chalk.red("✗")} ${validated.error}`);
+      return;
+    }
+
+    try {
+      const currentOrigins = await getFunctionCorsOrigins(functionId);
+      const normalizedOrigin = validated.origin as string;
+
+      if (currentOrigins.includes(normalizedOrigin)) {
+        console.log(`${chalk.yellow("!")} Origin ${chalk.cyan(normalizedOrigin)} already exists for function ${chalk.cyan(functionId)}.`);
+        return;
+      }
+
+      const updatedOrigins = [...currentOrigins, normalizedOrigin];
+      await setFunctionCorsOrigins(functionId, updatedOrigins);
+
+      console.log(`${chalk.green("✓")} Added CORS origin ${chalk.cyan(normalizedOrigin)} to function ${chalk.cyan(functionId)}.`);
+    } catch (error: any) {
+      handleCorsCommandError(error, "add CORS origin");
+    }
+  },
+};
@@ -0,0 +1,30 @@
+import chalk from "chalk";
+import {
+  getFunctionCorsOrigins,
+  handleCorsCommandError,
+  resolveFunctionId,
+  setFunctionCorsOrigins,
+} from "../../utils/cors_commands.js";
+
+export const clearCorsDefinition = {
+  name: "clear",
+  description: "Clear all CORS allowlist origins for a function.",
+  options: [{ name: "--id <id>", description: "Function ID (falls back to .shsf.json default id)" }],
+  action: async (options: { id?: string }) => {
+    const functionId = resolveFunctionId(options);
+    if (!functionId) return;
+
+    try {
+      const currentOrigins = await getFunctionCorsOrigins(functionId);
+      if (currentOrigins.length === 0) {
+        console.log(`${chalk.yellow("!")} CORS allowlist is already empty for function ${chalk.cyan(functionId)}.`);
+        return;
+      }
+
+      await setFunctionCorsOrigins(functionId, []);
+      console.log(`${chalk.green("✓")} Cleared all CORS origins for function ${chalk.cyan(functionId)}.`);
+    } catch (error: any) {
+      handleCorsCommandError(error, "clear CORS origins");
+    }
+  },
+};
@@ -0,0 +1,27 @@
+import chalk from "chalk";
+import { getFunctionCorsOrigins, handleCorsCommandError, resolveFunctionId } from "../../utils/cors_commands.js";
+
+export const listCorsDefinition = {
+  name: "list",
+  description: "List CORS allowlist origins for a function.",
+  options: [{ name: "--id <id>", description: "Function ID (falls back to .shsf.json default id)" }],
+  action: async (options: { id?: string }) => {
+    const functionId = resolveFunctionId(options);
+    if (!functionId) return;
+
+    try {
+      const origins = await getFunctionCorsOrigins(functionId);
+      if (origins.length === 0) {
+        console.log(`${chalk.yellow("!")} No CORS allowlist origins configured for function ${chalk.cyan(functionId)}.`);
+        return;
+      }
+
+      console.log(`${chalk.blue("CORS Origins")} for function ${chalk.cyan(functionId)}:`);
+      origins.forEach((origin) => {
+        console.log(`- ${chalk.cyan(origin)}`);
+      });
+    } catch (error: any) {
+      handleCorsCommandError(error, "list CORS origins");
+    }
+  },
+};
@@ -0,0 +1,41 @@
+import chalk from "chalk";
+import {
+  getFunctionCorsOrigins,
+  handleCorsCommandError,
+  resolveFunctionId,
+  setFunctionCorsOrigins,
+  validateSingleOrigin,
+} from "../../utils/cors_commands.js";
+
+export const removeCorsDefinition = {
+  name: "remove <origin>",
+  description: "Remove a CORS allowlist origin (must start with http:// or https://).",
+  options: [{ name: "--id <id>", description: "Function ID (falls back to .shsf.json default id)" }],
+  action: async (origin: string, options: { id?: string }) => {
+    const functionId = resolveFunctionId(options);
+    if (!functionId) return;
+
+    const validated = validateSingleOrigin(origin);
+    if (validated.error) {
+      console.error(`${chalk.red("✗")} ${validated.error}`);
+      return;
+    }
+
+    try {
+      const currentOrigins = await getFunctionCorsOrigins(functionId);
+      const normalizedOrigin = validated.origin as string;
+
+      if (!currentOrigins.includes(normalizedOrigin)) {
+        console.log(`${chalk.yellow("!")} Origin ${chalk.cyan(normalizedOrigin)} is not set for function ${chalk.cyan(functionId)}.`);
+        return;
+      }
+
+      const updatedOrigins = currentOrigins.filter((existingOrigin) => existingOrigin !== normalizedOrigin);
+      await setFunctionCorsOrigins(functionId, updatedOrigins);
+
+      console.log(`${chalk.green("✓")} Removed CORS origin ${chalk.cyan(normalizedOrigin)} from function ${chalk.cyan(functionId)}.`);
+    } catch (error: any) {
+      handleCorsCommandError(error, "remove CORS origin");
+    }
+  },
+};
@@ -0,0 +1,62 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const functionsCountDefinition = {
+  name: "functions",
+  description: "Counts the amount of functions the current user has.",
+  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(full: boolean = false) {
+  const client = await getApiClient();
+
+  try {
+    const response = await client.get("/api/functions");
+
+    if (response.status === 200 && response.data.data) {
+      const functions = response.data.data;
+      const count = functions.length;
+
+      if (full && count > 0) {
+        console.log(chalk.blue("Functions List:"));
+        functions.forEach((f: any) => {
+          const namespaceInfo = f.namespace ? chalk.gray(` [NS: ${f.namespace.id}]`) : "";
+          console.log(`- ${chalk.cyan(f.name)} ${chalk.gray(`(${f.id})`)}${namespaceInfo}`);
+          if (f.description) {
+            console.log(`  ${chalk.italic.gray(f.description)}`);
+          }
+        });
+        console.log("");
+      }
+
+      console.log(
+        `${chalk.green("✓")} You have ${chalk.bgGreen.black(` ${count} `)} functions.`,
+      );
+    } 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 fetch function count.`,
+      );
+      console.error(`Status Code: ${chalk.red(error.response.status)}`);
+      console.error(
+        `Message: ${chalk.yellow(error.response.data.message || "Unknown error from server")}`,
+      );
+    } else {
+      console.error(
+        `${chalk.red("✗")} Local error occurred.`,
+      );
+      console.error(`Error: ${chalk.yellow(error.message)}`);
+    }
+  }
+}
@@ -0,0 +1,57 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const namespacesCountDefinition = {
+  name: "namespaces",
+  description: "Counts the amount of namespaces the current user has.",
+  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(full: boolean = false) {
+  const client = await getApiClient();
+
+  try {
+    const response = await client.get("/api/namespaces");
+
+    if (response.status === 200 && response.data.data) {
+      const namespaces = response.data.data;
+      const count = namespaces.length;
+
+      if (full && count > 0) {
+        console.log(chalk.blue("Namespaces List:"));
+        namespaces.forEach((ns: any) => {
+          console.log(`- ${chalk.cyan(ns.name)} ${chalk.gray(`(${ns.id})`)}`);
+        });
+        console.log("");
+      }
+
+      console.log(
+        `${chalk.green("✓")} You have ${chalk.bgGreen.black(` ${count} `)} namespaces.`,
+      );
+    } 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 fetch namespace count.`,
+      );
+      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);
+    }
+  }
+}
@@ -0,0 +1,58 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const storagesCountDefinition = {
+  name: "storages",
+  description: "Counts the amount of storages the current user has.",
+  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(full: boolean = false) {
+  const client = await getApiClient();
+
+  try {
+    const response = await client.get("/api/storage");
+
+    if (response.status === 200 && response.data.data) {
+      const storages = response.data.data;
+      const count = storages.length;
+
+      if (full && count > 0) {
+        console.log(chalk.blue("Storages List:"));
+        storages.forEach((s: any) => {
+          const purposeInfo = s.purpose ? chalk.gray(` - ${s.purpose}`) : "";
+          console.log(`- ${chalk.cyan(s.name)}${purposeInfo}`);
+        });
+        console.log("");
+      }
+
+      console.log(
+        `${chalk.green("✓")} You have ${chalk.bgGreen.black(` ${count} `)} storages.`,
+      );
+    } 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 fetch storage count.`,
+      );
+      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);
+    }
+  }
+}
@@ -0,0 +1,62 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const triggersCountDefinition = {
+  name: "triggers",
+  description: "Counts the amount of triggers the current user has.",
+  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(full: boolean = false) {
+  const client = await getApiClient();
+
+  try {
+    const response = await client.get("/api/triggers");
+
+    if (response.status === 200 && response.data.data) {
+      const triggers = response.data.data;
+      const count = triggers.length;
+
+      if (full && count > 0) {
+        console.log(chalk.blue("Triggers List:"));
+        triggers.forEach((t: any) => {
+          const functionInfo = t.function ? chalk.gray(` [Func: ${t.function.name}]`) : "";
+          const cronInfo = t.cron ? chalk.yellow(` (Cron: ${t.cron})`) : "";
+          console.log(`- ${chalk.cyan(t.name)} ${chalk.gray(`(${t.id})`)}${functionInfo}${cronInfo}`);
+          if (t.description) {
+            console.log(`  ${chalk.italic.gray(t.description)}`);
+          }
+        });
+        console.log("");
+      }
+
+      console.log(
+        `${chalk.green("✓")} You have ${chalk.bgGreen.black(` ${count} `)} triggers.`,
+      );
+    } 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 fetch trigger count.`,
+      );
+      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);
+    }
+  }
+}
@@ -0,0 +1,75 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const createFunctionDefinition = {
+  name: "function",
+  description: "Create a new serverless function.",
+  options: [
+    { name: "--name <name>", description: "Function name", required: true },
+    { name: "--description <description>", description: "Function description", required: true },
+    { name: "--image <image>", description: "Docker image tag", required: true },
+    { name: "--startup-file <file>", description: "Startup file name", required: true },
+    { name: "--namespace-id <id>", description: "Namespace ID", required: true },
+    { 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 (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,
+      image: options.image,
+      startup_file: options.startupFile,
+      namespaceId: parseInt(options.namespaceId),
+      executionAlias: options.executionAlias,
+      docker_mount: !!options.dockerMount,
+      ffmpeg_install: !!options.ffmpegInstall,
+      imported: !!options.imported,
+      cache_enabled: parsedCacheEnabled,
+      cache_ttl: parsedCacheTtl,
+    };
+
+    const client = await getApiClient();
+
+    try {
+      const response = await client.post("/api/function", data);
+
+      if (response.status === 200) {
+        console.log(
+          `${chalk.green("✓")} Function ${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 function: ${chalk.yellow(error.response.data.message || "Unknown error")}`,
+        );
+      } else {
+        console.error(`${chalk.red("✗")} Error: ${error.message}`);
+      }
+    }
+  },
+};
@@ -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/namespace", 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}`);
+      }
+    }
+  },
+};
@@ -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}`);
+      }
+    }
+  },
+};
@@ -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);
+    }
+  }
+}
@@ -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);
+    }
+  }
+}
@@ -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);
+    }
+  }
+}
@@ -0,0 +1,96 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const updateFunctionDefinition = {
+  name: "add",
+  description:
+    "Adds or updates environment variables for a serverless function.",
+  options: [
+    { name: "--id <id>", description: "Function ID", required: true },
+    {
+      name: "--name <name>",
+      description: "Environment variable name",
+      required: true,
+    },
+    {
+      name: "--value <value>",
+      description: "Environment variable value",
+      required: true,
+    },
+  ],
+  action: async (options: any) => {
+    if (!options.id || !options.name || !options.value) {
+      console.error(
+        `${chalk.red("✗")} Error: Missing required options (--id, --name, --value)`,
+      );
+      return;
+    }
+
+    const client = await getApiClient();
+    let existingEnv: { name: string; value: string }[] = [];
+
+    try {
+      const response = await client.get(`/api/function/${options.id}`);
+      const functionData = response.data.data || response.data;
+      existingEnv = functionData.env || [];
+      
+      if (typeof existingEnv === 'string') {
+        try {
+          existingEnv = JSON.parse(existingEnv);
+        } catch (e: any) {
+          existingEnv = [];
+        }
+      }
+      if (!Array.isArray(existingEnv)) {
+        existingEnv = [];
+      }
+    } catch (error: any) {
+      console.error(
+        `${chalk.red("✗")} Error fetching function data: ${error.message}`,
+      );
+      return;
+    }
+
+    const newEnv = [...existingEnv];
+    const existingIndex = newEnv.findIndex((env) => env.name === options.name);
+    const isUpdate = existingIndex !== -1;
+
+    if (isUpdate) {
+      newEnv[existingIndex].value = options.value;
+    } else {
+      newEnv.push({ name: options.name, value: options.value });
+    }
+
+    const totalCount = newEnv.length;
+
+    try {
+      const response = await client.patch(`/api/function/${options.id}`, {
+        environment: newEnv,
+      });
+
+      if (response.status === 200) {
+        const actionText = isUpdate ? "updated" : "added";
+        console.log(
+          `${chalk.green("✓")} Environment variable ${chalk.cyan(options.name)} ${actionText} successfully for function ${chalk.cyan(options.id)}.`,
+        );
+        console.log(
+          `${chalk.blue("ℹ")} Total environment variables: ${totalCount}`,
+        );
+      } else {
+        console.error(
+          `${chalk.red("✗")} Unexpected response from server: ${response.status}`,
+        );
+      }
+    } catch (error: any) {
+      if (error.response?.status === 404) {
+        console.error(
+          `${chalk.red("✗")} Function with ID ${chalk.yellow(options.id)} not found.`,
+        );
+      } else {
+        console.error(
+          `${chalk.red("✗")} Failed to update: ${chalk.yellow(error.response?.data?.message || error.message)}`,
+        );
+      }
+    }
+  },
+};
@@ -0,0 +1,33 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const flushFunctionDefinition = {
+  name: "flush",
+  description: "Removes ALL environment variables from a serverless function.",
+  options: [
+    { name: "--id <id>", description: "Function ID", required: true },
+  ],
+  action: async (options: any) => {
+    if (!options.id) {
+      console.error(`${chalk.red("✗")} Error: --id is required`);
+      return;
+    }
+
+    const client = await getApiClient();
+
+    try {
+      const response = await client.patch(`/api/function/${options.id}`, {
+        environment: [],
+      });
+
+      if (response.status === 200) {
+        console.log(
+          `${chalk.green("✓")} All environment variables flushed for function ${chalk.cyan(options.id)}.`
+        );
+        console.log(`${chalk.blue("ℹ")} Total environment variables: 0`);
+      }
+    } catch (error: any) {
+      console.error(`${chalk.red("✗")} Error: ${error.response?.data?.message || error.message}`);
+    }
+  },
+};
@@ -0,0 +1,53 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const listEnvDefinition = {
+  name: "list",
+  description: "Lists all environment variables for a serverless function.",
+  options: [
+    { name: "--id <id>", description: "Function ID", required: true },
+  ],
+  action: async (options: any) => {
+    if (!options.id) {
+      console.error(`${chalk.red("✗")} Error: --id is required`);
+      return;
+    }
+
+    const client = await getApiClient();
+
+    try {
+      const response = await client.get(`/api/function/${options.id}`);
+      
+      const functionData = response.data.data || response.data;
+      let env = functionData.env;
+
+      if (typeof env === 'string' && env.length > 0) {
+        try {
+          env = JSON.parse(env);
+        } catch (e: any) {
+          console.error(`${chalk.red("✗")} Error parsing env string: ${e.message}`);
+          env = [];
+        }
+      }
+
+      const envList: { name: string; value: string }[] = Array.isArray(env) ? env : [];
+
+      if (envList.length === 0) {
+        console.log(`${chalk.yellow("!")} No environment variables found for function ${chalk.cyan(options.id)}.`);
+        return;
+      }
+
+      console.log(`${chalk.blue("ℹ")} Environment variables for function ${chalk.cyan(options.id)}:`);
+      envList.forEach((item) => {
+        console.log(`${chalk.green("•")} ${chalk.cyan(item.name)}=${chalk.white(item.value)}`);
+      });
+      console.log(`${chalk.blue("ℹ")} Total: ${envList.length}`);
+    } catch (error: any) {
+      if (error.response?.status === 404) {
+        console.error(`${chalk.red("✗")} Function with ID ${chalk.yellow(options.id)} not found.`);
+      } else {
+        console.error(`${chalk.red("✗")} Error fetching environment variables: ${chalk.yellow(error.response?.data?.message || error.message)}`);
+      }
+    }
+  },
+};
@@ -0,0 +1,62 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const removeFunctionDefinition = {
+  name: "remove",
+  description: "Removes a specific environment variable from a serverless function.",
+  options: [
+    { name: "--id <id>", description: "Function ID", required: true },
+    {
+      name: "--name <name>",
+      description: "Environment variable name to remove",
+      required: true,
+    },
+  ],
+  action: async (options: any) => {
+    if (!options.id || !options.name) {
+      console.error(`${chalk.red("✗")} Error: --id and --name are required`);
+      return;
+    }
+
+    const client = await getApiClient();
+
+    try {
+      const response = await client.get(`/api/function/${options.id}`);
+      const functionData = response.data.data || response.data;
+      let existingEnv: { name: string; value: string }[] = functionData.env || [];
+
+      if (typeof existingEnv === 'string') {
+        try {
+          existingEnv = JSON.parse(existingEnv);
+        } catch (e: any) {
+          existingEnv = [];
+        }
+      }
+
+      if (!Array.isArray(existingEnv)) {
+        existingEnv = [];
+      }
+
+      const initialCount = existingEnv.length;
+      const filteredEnv = existingEnv.filter((env) => env.name !== options.name);
+
+      if (filteredEnv.length === initialCount) {
+        console.warn(`${chalk.yellow("!")} Variable ${chalk.cyan(options.name)} not found. No changes made.`);
+        return;
+      }
+
+      const patchResponse = await client.patch(`/api/function/${options.id}`, {
+        environment: filteredEnv,
+      });
+
+      if (patchResponse.status === 200) {
+        console.log(
+          `${chalk.green("✓")} Variable ${chalk.cyan(options.name)} removed successfully from function ${chalk.cyan(options.id)}.`
+        );
+        console.log(`${chalk.blue("ℹ")} Remaining environment variables: ${filteredEnv.length}`);
+      }
+    } catch (error: any) {
+      console.error(`${chalk.red("✗")} Error: ${error.response?.data?.message || error.message}`);
+    }
+  },
+};
@@ -0,0 +1,46 @@
+import chalk from "chalk";
+import fs from "fs/promises";
+import { getApiClient } from "../../api.js";
+import { createOrUpdateFile, handleAxiosError } from "../../utils/fileops.js";
+
+export const fileCreateDefinition = {
+  name: "create",
+  description: "Create or update a file in a function.",
+  options: [
+    { name: "--function-id <id>", description: "Function ID", required: true },
+    { name: "--filename <name>", description: "Remote filename", 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();
+    try {
+      await createOrUpdateFile(client, options.functionId, options.filename, content as string);
+      console.log(
+        `${chalk.green("✓")} File ${chalk.cyan(options.filename)} created/updated successfully in function ${chalk.cyan(options.functionId)}.`,
+      );
+    } catch (error: any) {
+      handleAxiosError(error);
+    }
+  },
+};
@@ -0,0 +1,23 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+import { deleteFile, handleAxiosError } from "../../utils/fileops.js";
+
+export const fileDeleteDefinition = {
+  name: "delete",
+  description: "Delete a file from a function.",
+  options: [
+    { name: "--function-id <id>", description: "Function ID", required: true },
+    { name: "--file-id <id>", description: "File ID (from 'file list')", required: true },
+  ],
+  action: async (options: any) => {
+    const client = await getApiClient();
+    try {
+      await deleteFile(client, options.functionId, options.fileId, undefined);
+      console.log(
+        `${chalk.green("✓")} File ${chalk.cyan(options.fileId)} deleted from function ${chalk.cyan(options.functionId)}.`,
+      );
+    } catch (error: any) {
+      handleAxiosError(error);
+    }
+  },
+};
@@ -0,0 +1,38 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+import { listFiles, handleAxiosError } from "../../utils/fileops.js";
+
+export const fileListDefinition = {
+  name: "list",
+  description: "List files in a function.",
+  options: [
+    { name: "--function-id <id>", description: "Function ID", required: true },
+  ],
+  action: async (options: any) => {
+    const client = await getApiClient();
+
+    try {
+      const files = await listFiles(client, options.functionId);
+
+      if (files) {
+
+        if (!Array.isArray(files) || files.length === 0) {
+          console.log(`${chalk.yellow("!")} No files found.`);
+          return;
+        }
+
+        console.log(chalk.blue("Files:"));
+        console.log(chalk.gray(`${"ID".padEnd(25)} ${"Filename"}`));
+        files.forEach((file: any) => {
+          const id = String(file.id ?? file.name ?? "");
+          console.log(`${chalk.cyan(id.padEnd(25))} ${chalk.white(file.filename || file.name)}`);
+        });
+        console.log(`\n${chalk.green("✓")} Found ${chalk.bgGreen.black(` ${files.length} `)} files.`);
+      } else {
+        console.log(`${chalk.yellow("!")} Unexpected response from server.`);
+      }
+    } catch (error: any) {
+      handleAxiosError(error);
+    }
+  },
+};
@@ -0,0 +1,24 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+import { renameFile, handleAxiosError } from "../../utils/fileops.js";
+
+export const fileRenameDefinition = {
+  name: "rename",
+  description: "Rename a file in a function.",
+  options: [
+    { name: "--function-id <id>", description: "Function ID", required: true },
+    { name: "--file-id <id>", description: "File ID", required: true },
+    { name: "--new-filename <name>", description: "New filename", required: true },
+  ],
+  action: async (options: any) => {
+    const client = await getApiClient();
+    try {
+      await renameFile(client, options.functionId, options.fileId, options.newFilename);
+      console.log(
+        `${chalk.green("✓")} File ${chalk.cyan(options.fileId)} renamed to ${chalk.cyan(options.newFilename)} successfully.`,
+      );
+    } catch (error: any) {
+      handleAxiosError(error);
+    }
+  },
+};
@@ -0,0 +1,152 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+import { AxiosResponse } from "axios";
+
+export const functionExecuteDefinition = {
+  name: "execute",
+  description: "Execute a function and stream the output (debug/internal).",
+  options: [
+    { name: "--id <id>", description: "Function ID", required: true },
+    { name: "--payload <json>", description: "JSON payload for execution", required: false },
+    { name: "--no-stream", description: "Disable streaming and get final result only", required: false, default: false },
+  ],
+  action: async (options: any) => {
+    const client = await getApiClient();
+    
+    // Explicitly check for noStream from commander
+    // Commander uses camelsCase for options, so --no-stream becomes stream: false
+    // but we use --no-stream which commander natively handles as a boolean toggle
+    const useStream = options.stream !== false;
+
+    let payload = {};
+    if (options.payload) {
+      try {
+        payload = JSON.parse(options.payload);
+      } catch (error: any) {
+        console.error(`${chalk.red("✗")} Invalid JSON payload: ${chalk.yellow(error.message)}`);
+        return;
+      }
+    }
+
+    const handleJsonChunk = (chunk: string) => {
+      const trimmed = chunk.trim();
+      if (!trimmed) return;
+
+      try {
+        const obj = JSON.parse(trimmed);
+        if (obj.type === "output" && obj.content) {
+          process.stdout.write(obj.content);
+        } else if (obj.type === "end") {
+          if (obj.exitCode !== 0 && obj.exitCode !== undefined) {
+            console.error(`\n${chalk.red("✗")} Execution failed with exit code ${obj.exitCode}`);
+          } else {
+            console.log(`\n${chalk.green("✓")} Execution completed.`);
+          }
+          if (obj.result !== undefined) {
+            console.log(chalk.blue("Result:"), typeof obj.result === 'object' ? JSON.stringify(obj.result, null, 2) : obj.result);
+          }
+          if (obj.took) {
+            const total = obj.took.find((t: any) => t.description === "Total");
+            if (total) {
+              console.log(chalk.gray(`Total time: ${total.value}s`));
+            }
+          }
+        }
+      } catch (e) {
+        // If it's not JSON, it might be raw output from a non-stream response 
+        // that got into the stream handler mistakenly or just raw noise
+        if (trimmed.length > 0) {
+          process.stdout.write(chunk);
+        }
+      // Not a full JSON object yet or invalid JSON
+      }
+    };
+
+    console.log(`${chalk.blue("ℹ")} Executing function ${chalk.cyan(options.id)} (stream: ${useStream})...`);
+
+    try {
+      const response = await client.post(`/api/function/${options.id}/execute`, 
+        { run: payload },
+        { 
+          params: { stream: useStream ? "true" : "false" },
+          responseType: useStream ? "stream" : "json"
+        }
+      );
+
+      if (useStream) {
+        const stream = (response as AxiosResponse).data;
+        let buffer = "";
+        
+        return new Promise<void>((resolve, reject) => {
+          stream.on("data", (chunk: any) => {
+            const str = chunk.toString();
+            buffer += str;
+            
+            // Try to split by potential JSON boundaries
+            // Matches cases like ...}{...
+            const pattern = /\}\s*\{/g;
+            let lastIndex = 0;
+            let match;
+
+            while ((match = pattern.exec(buffer)) !== null) {
+              const part = buffer.slice(lastIndex, match.index + 1);
+              handleJsonChunk(part);
+              lastIndex = match.index + match[0].indexOf('{');
+            }
+
+            buffer = buffer.slice(lastIndex);
+
+            // Attempt to parse the remaining buffer if it looks like a complete object
+            try {
+              if (buffer.trim().startsWith('{') && buffer.trim().endsWith('}')) {
+                handleJsonChunk(buffer);
+                buffer = "";
+              }
+            } catch (e) {
+              // Wait for more data
+            }
+          });
+
+          stream.on("end", () => {
+            if (buffer.trim()) {
+              handleJsonChunk(buffer);
+            }
+            resolve();
+          });
+
+          stream.on("error", (err: Error) => {
+            console.error(`\n${chalk.red("✗")} Stream error: ${err.message}`);
+            reject(err);
+          });
+        });
+      } else {
+        // Non-stream returns just the output content or the body
+        const result = response.data;
+        if (typeof result === 'string') {
+          process.stdout.write(result);
+        } else if (result && result.data && typeof result.data === 'string') {
+          process.stdout.write(result.data);
+        } else if (result && typeof result.output === 'string') {
+          process.stdout.write(result.output);
+        } else if (result && typeof result.result === 'string') {
+          process.stdout.write(result.result);
+        } else if (result && result.data && result.data.output) {
+          process.stdout.write(result.data.output);
+        } else {
+          process.stdout.write(JSON.stringify(result, null, 2));
+        }
+        console.log(`\n${chalk.green("✓")} Execution completed.`);
+      }
+    } catch (error: any) {
+      if (error.response) {
+        console.error(
+          `${chalk.red("✗")} Execution failed: ${chalk.yellow(error.response.data?.message || error.response.statusText || "Unknown error")}`,
+        );
+      } else if (error.request) {
+        console.error(`${chalk.red("✗")} No response received from server.`);
+      } else {
+        console.error(`${chalk.red("✗")} Error: ${error.message}`);
+      }
+    }
+  },
+};
@@ -0,0 +1,56 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const pipInstallDefinition = {
+  name: "pipinstall",
+  description: "Install Python dependencies for a function using requirements.txt",
+  options: [
+    {
+      name: "--id <id>",
+      description: "The ID of the function.",
+      required: true,
+    },
+  ],
+  action: async (options: { id: string }) => {
+    await pipInstallFunction(options.id);
+  },
+};
+
+async function pipInstallFunction(id: string) {
+  const client = await getApiClient();
+
+  try {
+    const response = await client.post(`/api/function/${id}/pip-install`);
+
+    if (response.status === 200) {
+      console.log(`${chalk.green("✓")} Dependencies installed successfully for function ${chalk.yellow(id)}.`);
+      if (response.data && response.data.status) {
+        console.log(`${chalk.gray("Status:")} ${response.data.status}`);
+      }
+    } 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 install dependencies.`,
+      );
+      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("✗")} Failed to install dependencies.`,
+      );
+      console.error(
+        `${chalk.yellow("Could not connect to the SHSF instance. Check your connection.")}`,
+      );
+    } else {
+      console.error(`${chalk.red("✗")} Error:`, error.message);
+    }
+  }
+}
@@ -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);
+    }
+  }
+}
@@ -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);
+    }
+  }
+}
@@ -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);
+    }
+  }
+}
@@ -0,0 +1,37 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+import fs from "fs";
+import path from "path";
+
+export const pullDefinition = {
+  name: "pull",
+  description: "Pull files from a remote function.",
+  options: [
+    { name: "--id <id>", description: "Function ID", required: true },
+    { name: "--into <path>", description: "Target directory", required: true },
+    { name: "--force", description: "Force overwrite" },
+  ],
+  action: async (options: any) => {
+    const client = await getApiClient();
+
+    try {
+      const response = await client.get(`/api/function/${options.id}/files`);
+      const files = response.data.data; // Expecting { name: string, content: string }[]
+
+      if (!fs.existsSync(options.into)) {
+        fs.mkdirSync(options.into, { recursive: true });
+      } else if (fs.readdirSync(options.into).length > 0 && !options.force) {
+        console.error(chalk.red(`Directory ${options.into} is not empty. Use --force to overwrite.`));
+        return;
+      }
+      for (const file of files) {
+        fs.writeFileSync(path.join(options.into, file.name), file.content);
+        const byteSize = Buffer.byteLength(file.content, 'utf8');
+        console.log(chalk.green(`Pulled ${file.name} (${byteSize} bytes)`));
+      }
+      console.log(chalk.green(`Successfully pulled ${files.length} files into ${options.into}`));
+    } catch (error: any) {
+      console.error(chalk.red(`Failed to pull files: ${error.message}`));
+    }
+  },
+};
@@ -0,0 +1,232 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+import fs from "fs";
+import path from "path";
+import {
+  defaultUnpushableFiles,
+  readIgnoreFile,
+  matchesAnyPattern,
+  readMappingFile,
+} from "../../utils/push_helpers.js";
+import { createHash } from "crypto";
+
+
+
+import type { ApiClient } from "../../types/apiClient.js";
+
+async function deleteNonexistentFiles(
+  currentFiles: any[],
+  files: any[],
+  client: ApiClient,
+  options: any,
+): Promise<{ didDeletion: boolean }> {
+  let didDeletion = false;
+  for (const currentFile of currentFiles) {
+    if (!files.some((f: any) => f.filename === currentFile.name)) {
+      try {
+        await client.delete(
+          `/api/function/${options.id}/file/${currentFile.id}`,
+          {
+            data: { filename: currentFile.name },
+          },
+        );
+      } catch (error: any) {
+        throw error;
+      }
+      console.log(
+        chalk.green(`Deleted ${currentFile.name} from function ${options.id}`),
+      );
+      didDeletion = true;
+    }
+  }
+  return { didDeletion };
+}
+
+export const pushDefinition = {
+  name: "push",
+  description: "Push files to a remote function.",
+  options: [
+    { name: "--id <id>", description: "Function ID" },
+    { name: "--from <path>", description: "Source directory" },
+    { name: "--force", description: "Force overwrite" },
+  ],
+  action: async (options: any) => {
+    const client = await getApiClient();
+
+    // Load mapping if options are missing
+    const mapping = readMappingFile();
+    if (!options.id && mapping?.id) {
+      options.id = mapping.id;
+      console.log(chalk.blue(`Using mapped id ${options.id} from .shsf.json`));
+    }
+    if (!options.from && mapping?.from) {
+      options.from = mapping.from;
+      console.log(chalk.blue(`Using mapped from ${options.from} from .shsf.json`));
+    }
+
+    const hadMapping = !!mapping;
+
+    if (!options.from) {
+      console.error(chalk.red("Source path not provided."));
+      return;
+    }
+
+    if (!fs.existsSync(options.from)) {
+      console.error(chalk.red(`Source ${options.from} does not exist.`));
+      return;
+    }
+    let didDeletion = false; // Track if any deletions were made
+
+    const currentFilesResponse = await client.get(
+      `/api/function/${options.id}/files`,
+    );
+    const currentFiles = currentFilesResponse.data.data; // Expecting { name: string, id: string [...] }[]
+
+    // Read ignore patterns from .shsfignore (in source dir or cwd) and merge with defaults
+    const customPatterns = readIgnoreFile(options.from);
+    const combinedPatterns = [...defaultUnpushableFiles, ...customPatterns];
+
+    // Read local files and filter to only include files (exclude directories)
+    const files = fs
+      .readdirSync(options.from)
+      .map((file) => {
+        const filePath = path.join(options.from, file);
+        return { filename: file, filePath };
+      })
+      .filter(({ filePath }) => fs.statSync(filePath).isFile())
+      .filter(({ filename }) => !matchesAnyPattern(filename, combinedPatterns))
+      .map(({ filename, filePath }) => ({
+        filename,
+        content: fs.readFileSync(filePath, "utf-8"),
+      }));
+
+    if (!options.force && files.length > 5) {
+      console.log(
+        chalk.yellow("Too many modifications. Please use --force to confirm."),
+      );
+      return;
+    }
+
+    // Push new and modified files
+    let pushedFilesCount = 0;
+    try {
+      for (const file of files) {
+        // Hash first, save traffic
+        const fileHash = createHash("md5").update(file.content).digest("hex");
+        const currentFile = currentFiles.find(
+          (f: any) => f.name === file.filename,
+        );
+        if (currentFile) {
+          const currentFileHash = createHash("md5")
+            .update(currentFile.content || "")
+            .digest("hex");
+          if (fileHash === currentFileHash) {
+            console.log(
+              chalk.yellow(
+                `Skipping ${file.filename}, no changes detected for function ${options.id}`,
+              ),
+            );
+            continue;
+          }
+        }
+
+        const filenameLower = file.filename.toLowerCase();
+        // Unpushable file check (also check custom patterns)
+        if (matchesAnyPattern(filenameLower, combinedPatterns)) {
+          console.log(
+            chalk.yellow(
+              `Skipping ${file.filename}, it matches unpushable patterns for function ${options.id}`,
+            ),
+          );
+          continue;
+        }
+
+        await client.put(`/api/function/${options.id}/file`, {
+          filename: file.filename,
+          code: file.content,
+        });
+
+        const byteSize = Buffer.byteLength(file.content, "utf8");
+        console.log(
+          chalk.green(
+            `Pushed ${file.filename} (${byteSize} bytes) to function ${options.id}`,
+          ),
+        );
+        pushedFilesCount++;
+      }
+
+      // Delete files that no longer exist on the remote AFTER pushing new/updated files
+      // This avoids the "cannot delete only file" error if we are pushing at least one file.
+      try {
+        const deletionResult = await deleteNonexistentFiles(
+          currentFiles,
+          files,
+          client,
+          options,
+        );
+        if (deletionResult.didDeletion) {
+          didDeletion = true;
+        }
+      } catch (error: any) {
+        if (error.response) {
+          console.error(
+            chalk.red(
+              `Failed to delete files: ${error.response.data?.message || error.response.statusText}`,
+            ),
+          );
+        } else {
+          console.error(chalk.red(`Error during deletion: ${error.message}`));
+        }
+      }
+
+      console.log(
+        chalk.green(
+          `Successfully pushed ${pushedFilesCount} files to function ${options.id}`,
+        ),
+      );
+
+      // If there was no mapping file and the user provided --id and --from, create a .shsf.json
+      if (!hadMapping && options.id && options.from) {
+        try {
+          const mapPath = path.join(process.cwd(), ".shsf.json");
+          if (!fs.existsSync(mapPath)) {
+            const data = { default: { id: options.id, from: options.from } };
+            fs.writeFileSync(mapPath, JSON.stringify(data, null, 2), { encoding: "utf-8" });
+            console.log("");
+            console.log(
+              chalk.green(`Wrote .shsf.json mapping to ${mapPath}`),
+            );
+            console.log(
+              chalk.blue(
+                `Tip: Next time you can omit --id and --from — the CLI will use values from .shsf.json`,
+              ),
+            );
+          }
+        } catch (err: any) {
+          console.error(chalk.yellow(`Could not write .shsf.json: ${err?.message || err}`));
+        }
+      }
+
+      if (didDeletion) {
+        console.log("");
+        console.log(
+          chalk.blue(
+            `Hint: We might delete files that you renamed, but don't worry, we'll push the newly named file right after!`,
+          ),
+        );
+      }
+    } catch (error: any) {
+      if (error.response) {
+        console.error(
+          chalk.red(
+            `Failed to push files: ${error.response.data?.message || error.response.statusText}`,
+          ),
+        );
+      } else if (error.request) {
+        console.error(chalk.red("No response received from server."));
+      } else {
+        console.error(chalk.red(`Error: ${error.message}`));
+      }
+    }
+  },
+};
@@ -0,0 +1,91 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+interface ShsfFile {
+  name: string;
+  content: string;
+}
+
+export const reqAddDefinition = {
+  name: "add <package>",
+  description: "Add a package to the requirements.txt of a function.",
+  options: [
+    { name: "--to <id>", description: "The ID of the function (deprecated alias for --id)." },
+    { name: "--id <id>", description: "The ID of the function.", required: true },
+  ],
+  action: async (pkg: string, options: { to?: string; id?: string }) => {
+    const functionId = options.id ?? options.to;
+    if (!functionId) {
+      console.error(`${chalk.red("✗")} Error: Function ID is required. Use ${chalk.cyan("--id <id>")}.`);
+      return;
+    }
+    const client = await getApiClient();
+
+    try {
+      // 1. Get current files of the function
+      const response = await client.get(`/api/function/${functionId}/files`);
+      let files: ShsfFile[] = response.data.data;
+      if (!Array.isArray(files)) files = [];
+
+      let requirementsFile = files.find(f => f.name === "requirements.txt");
+      let content = requirementsFile ? requirementsFile.content : "";
+
+      // 2. Add the package
+      const lines = content.split("\n");
+      
+      // Robust package name extraction
+      const getPkgName = (line: string) => {
+        const withoutComment = line.trim().split("#", 1)[0];
+        const basePart = withoutComment.split(";", 1)[0].trim();
+        if (!basePart) return null;
+        return basePart.split(/[!=>~<]/)[0].trim().toLowerCase();
+      };
+
+      const pkgToAddName = getPkgName(pkg);
+      if (!pkgToAddName) {
+        console.error(`${chalk.red("✗")} Invalid package format.`);
+        return;
+      }
+
+      const exists = lines.some(line => {
+        const lineName = getPkgName(line);
+        return lineName === pkgToAddName;
+      });
+
+      if (exists) {
+        console.log(`${chalk.yellow("!")} Package ${chalk.cyan(pkgToAddName)} is already in requirements.txt.`);
+        return;
+      }
+
+      // Preserve existing content structure
+      if (content && !content.endsWith("\n")) {
+        content += "\n";
+      }
+      content += pkg + "\n";
+
+      // 3. Overwrite/Create requirements.txt using function-based API
+      await client.put(`/api/function/${functionId}/file`, {
+        filename: "requirements.txt",
+        code: content,
+      });
+
+      console.log(`${chalk.green("✓")} Added ${chalk.cyan(pkg)} to requirements.txt for function ${chalk.yellow(functionId)}.`);
+    } catch (error: any) {
+      handleError(error, "add package");
+    }
+  },
+};
+
+function handleError(error: any, task: string) {
+  if (error.response) {
+    console.error(`${chalk.red("✗")} Failed to ${task}: ${chalk.yellow(error.response.data?.message || (error.response.data ? JSON.stringify(error.response.data) : error.message))}`);
+  } else if (error.request) {
+    console.error(
+      `${chalk.red("✗")} Failed to ${task}: ${chalk.yellow(
+        "No response received from server. Please check your network connection and try again."
+      )}`
+    );
+  } else {
+    console.error(`${chalk.red("✗")} Error: ${error.message}`);
+  }
+}
@@ -0,0 +1,97 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+interface ShsfFile {
+  name: string;
+  content: string;
+}
+
+export const reqRemoveDefinition = {
+  name: "remove <package>",
+  description: "Remove a package from the requirements.txt of a function.",
+  options: [
+    { name: "--from <id>", description: "The ID of the function (deprecated alias for --id)." },
+    { name: "--id <id>", description: "The ID of the function.", required: true },
+  ],
+  action: async (pkgToRemove: string, options: { from?: string; id?: string }) => {
+    const functionId = options.id ?? options.from;
+    if (!functionId) {
+      console.error(`${chalk.red("✗")} Error: Function ID is required. Use ${chalk.cyan("--id <id>")}.`);
+      return;
+    }
+    const client = await getApiClient();
+
+    try {
+      // 1. Get current files of the function
+      const response = await client.get(`/api/function/${functionId}/files`);
+      let files: ShsfFile[] = response.data.data;
+      if (!Array.isArray(files)) files = [];
+
+      const requirementsFile = files.find(f => f.name === "requirements.txt");
+      if (!requirementsFile) {
+        console.log(`${chalk.yellow("!")} No requirements.txt found for function ${chalk.yellow(functionId)}.`);
+        return;
+      }
+
+      const content = requirementsFile.content;
+      const lines = content.split("\n");
+      
+      const targetPkgName = pkgToRemove.trim().toLowerCase();
+      let removed = false;
+      
+      const newLines = lines.filter(line => {
+        const trimmedLine = line.trim();
+        // Preserve empty/whitespace-only lines
+        if (!trimmedLine) return true;
+        
+        // Strip inline comments and environment markers for matching purposes
+        const withoutComment = trimmedLine.split("#", 1)[0];
+        const basePart = withoutComment.split(";", 1)[0].trim();
+
+        // If there's no actual requirement (e.g., comment-only line), keep the line
+        if (!basePart) return true;
+
+        // Robust extraction (handles != <= >= ~= == and < >)
+        const currentPkgName = basePart.split(/[!=>~<]/)[0].trim().toLowerCase();
+        
+        if (currentPkgName === targetPkgName) {
+          removed = true;
+          return false;
+        }
+
+        return true;
+      });
+
+      if (!removed) {
+        console.log(`${chalk.yellow("!")} Package ${chalk.cyan(pkgToRemove)} was not found in requirements.txt.`);
+        return;
+      }
+
+      const newContent = newLines.join("\n");
+
+      // 2. Overwrite requirements.txt using function-based API
+      await client.put(`/api/function/${functionId}/file`, {
+        filename: "requirements.txt",
+        code: newContent,
+      });
+
+      console.log(`${chalk.green("✓")} Removed ${chalk.cyan(pkgToRemove)} from requirements.txt for function ${chalk.yellow(functionId)}.`);
+    } catch (error: any) {
+      handleError(error, "remove package");
+    }
+  },
+};
+
+function handleError(error: any, task: string) {
+  if (error.response) {
+    console.error(`${chalk.red("✗")} Failed to ${task}: ${chalk.yellow(error.response.data?.message || (error.response.data ? JSON.stringify(error.response.data) : error.message))}`);
+  } else if (error.request) {
+    console.error(
+      `${chalk.red("✗")} Failed to ${task}: ${chalk.yellow(
+        "No response received from server. Please check your network connection and try again."
+      )}`
+    );
+  } else {
+    console.error(`${chalk.red("✗")} Error: ${error.message}`);
+  }
+}
@@ -0,0 +1,35 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const clearItemsDefinition = {
+  name: "clear-items",
+  description: "Clear all items from a storage.",
+  options: [
+    { name: "--name <name>", description: "Storage name", required: true },
+  ],
+  action: async (options: any) => {
+    const client = await getApiClient();
+
+    try {
+      const response = await client.delete(`/api/storage/${options.name}/items`);
+
+      if (response.status === 200) {
+        console.log(
+          `${chalk.green("✓")} All items cleared from storage ${chalk.cyan(options.name)}!`,
+        );
+      } else {
+        console.log(
+          `${chalk.yellow("!")} Unexpected response from server: ${response.status}`,
+        );
+      }
+    } catch (error: any) {
+      if (error.response) {
+        console.error(
+          `${chalk.red("✗")} Failed to clear items: ${chalk.yellow(error.response.data.message || "Unknown error")}`,
+        );
+      } else {
+        console.error(`${chalk.red("✗")} Error: ${error.message}`);
+      }
+    }
+  },
+};
@@ -0,0 +1,41 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const createStorageDefinition = {
+  name: "create",
+  description: "Create a new storage.",
+  options: [
+    { name: "--name <name>", description: "Storage name", required: true },
+    { name: "--purpose <purpose>", description: "Storage purpose", required: true },
+  ],
+  action: async (options: any) => {
+    const data = {
+      name: options.name,
+      purpose: options.purpose,
+    };
+
+    const client = await getApiClient();
+
+    try {
+      const response = await client.post("/api/storage", data);
+
+      if (response.status === 200 || response.status === 201) {
+        console.log(
+          `${chalk.green("✓")} Storage ${chalk.cyan(data.name)} created successfully!`,
+        );
+      } else {
+        console.log(
+          `${chalk.yellow("!")} Unexpected response from server: ${response.status}`,
+        );
+      }
+    } catch (error: any) {
+      if (error.response) {
+        console.error(
+          `${chalk.red("✗")} Failed to create storage: ${chalk.yellow(error.response.data.message || "Unknown error")}`,
+        );
+      } else {
+        console.error(`${chalk.red("✗")} Error: ${error.message}`);
+      }
+    }
+  },
+};
@@ -0,0 +1,36 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const deleteItemDefinition = {
+  name: "delete-item",
+  description: "Delete a storage item.",
+  options: [
+    { name: "--name <name>", description: "Storage name", required: true },
+    { name: "--key <key>", description: "Item key", required: true },
+  ],
+  action: async (options: any) => {
+    const client = await getApiClient();
+
+    try {
+      const response = await client.delete(`/api/storage/${options.name}/item/${options.key}`);
+
+      if (response.status === 200) {
+        console.log(
+          `${chalk.green("✓")} Item ${chalk.cyan(options.key)} deleted from ${chalk.cyan(options.name)}!`,
+        );
+      } else {
+        console.log(
+          `${chalk.yellow("!")} Unexpected response from server: ${response.status}`,
+        );
+      }
+    } catch (error: any) {
+      if (error.response) {
+        console.error(
+          `${chalk.red("✗")} Failed to delete item: ${chalk.yellow(error.response.data.message || "Unknown error")}`,
+        );
+      } else {
+        console.error(`${chalk.red("✗")} Error: ${error.message}`);
+      }
+    }
+  },
+};
@@ -0,0 +1,35 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const deleteStorageDefinition = {
+  name: "delete",
+  description: "Delete a storage.",
+  options: [
+    { name: "--name <name>", description: "Storage name", required: true },
+  ],
+  action: async (options: any) => {
+    const client = await getApiClient();
+
+    try {
+      const response = await client.delete(`/api/storage/${options.name}`);
+
+      if (response.status === 200) {
+        console.log(
+          `${chalk.green("✓")} Storage ${chalk.cyan(options.name)} deleted successfully!`,
+        );
+      } else {
+        console.log(
+          `${chalk.yellow("!")} Unexpected response from server: ${response.status}`,
+        );
+      }
+    } catch (error: any) {
+      if (error.response) {
+        console.error(
+          `${chalk.red("✗")} Failed to delete storage: ${chalk.yellow(error.response.data.message || "Unknown error")}`,
+        );
+      } else {
+        console.error(`${chalk.red("✗")} Error: ${error.message}`);
+      }
+    }
+  },
+};
@@ -0,0 +1,42 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const listItemsDefinition = {
+  name: "get-items",
+  description: "List all items in a storage.",
+  options: [
+    { name: "--name <name>", description: "Storage name", required: true },
+  ],
+  action: async (options: any) => {
+    const client = await getApiClient();
+
+    try {
+      const response = await client.get(`/api/storage/${options.name}/items`);
+
+      if (response.status === 200 && response.data.data) {
+        const items = response.data.data;
+        if (items.length === 0) {
+          console.log(`${chalk.yellow("!")} Storage ${chalk.cyan(options.name)} is empty.`);
+          return;
+        }
+
+        console.log(chalk.blue(`Items in ${chalk.cyan(options.name)}:`));
+        items.forEach((item: any) => {
+          console.log(`- ${chalk.cyan(item.key)}: ${JSON.stringify(item.value)}`);
+        });
+      } else {
+        console.log(
+          `${chalk.yellow("!")} Unexpected response from server: ${response.status}`,
+        );
+      }
+    } catch (error: any) {
+      if (error.response) {
+        console.error(
+          `${chalk.red("✗")} Failed to list items: ${chalk.yellow(error.response.data.message || "Unknown error")}`,
+        );
+      } else {
+        console.error(`${chalk.red("✗")} Error: ${error.message}`);
+      }
+    }
+  },
+};
@@ -0,0 +1,40 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const listStoragesDefinition = {
+  name: "list",
+  description: "List all storages.",
+  action: async () => {
+    const client = await getApiClient();
+
+    try {
+      const response = await client.get("/api/storage");
+
+      if (response.status === 200 && response.data.data) {
+        const storages = response.data.data;
+        if (storages.length === 0) {
+          console.log(`${chalk.yellow("!")} No storages found.`);
+          return;
+        }
+
+        console.log(chalk.blue("Storages:"));
+        storages.forEach((s: any) => {
+          const purposeInfo = s.purpose ? chalk.gray(` - ${s.purpose}`) : "";
+          console.log(`- ${chalk.cyan(s.name)}${purposeInfo}`);
+        });
+      } else {
+        console.log(
+          `${chalk.yellow("!")} Unexpected response from server: ${response.status}`,
+        );
+      }
+    } catch (error: any) {
+      if (error.response) {
+        console.error(
+          `${chalk.red("✗")} Failed to list storages: ${chalk.yellow(error.response.data.message || "Unknown error")}`,
+        );
+      } else {
+        console.error(`${chalk.red("✗")} Error: ${error.message}`);
+      }
+    }
+  },
+};
@@ -0,0 +1,59 @@
+import chalk from "chalk";
+import { getApiClient } from "../../api.js";
+
+export const setItemDefinition = {
+  name: "set-item",
+  description: "Set a storage item.",
+  options: [
+    { name: "--name <name>", description: "Storage name", required: true },
+    { name: "--key <key>", description: "Item key", required: true },
+    { name: "--value <value>", description: "Item value (JSON string)", required: true },
+    { name: "--expires <expires>", description: "Expiration (ISO string or hours)" },
+  ],
+  action: async (options: any) => {
+    let value;
+    try {
+      value = JSON.parse(options.value);
+    } catch (e) {
+      // If not valid JSON, treat as string
+      value = options.value;
+    }
+
+    const data: any = {
+      key: options.key,
+      value: value,
+    };
+
+    if (options.expires) {
+      if (!isNaN(Number(options.expires))) {
+        data.expiresAt = Number(options.expires);
+      } else {
+        data.expiresAt = options.expires;
+      }
+    }
+
+    const client = await getApiClient();
+
+    try {
+      const response = await client.post(`/api/storage/${options.name}/item`, data);
+
+      if (response.status === 200 || response.status === 201) {
+        console.log(
+          `${chalk.green("✓")} Item ${chalk.cyan(options.key)} set successfully in ${chalk.cyan(options.name)}!`,
+        );
+      } else {
+        console.log(
+          `${chalk.yellow("!")} Unexpected response from server: ${response.status}`,
+        );
+      }
+    } catch (error: any) {
+      if (error.response) {
+        console.error(
+          `${chalk.red("✗")} Failed to set item: ${chalk.yellow(error.response.data.message || "Unknown error")}`,
+        );
+      } else {
+        console.error(`${chalk.red("✗")} Error: ${error.message}`);
+      }
+    }
+  },
+};
@@ -0,0 +1,52 @@
+import chalk from "chalk";
+import { getApiClient } from "../api.js";
+
+export const uiUrlDefinition = {
+    name: "uiurl",
+    description: "Get the URL for the SHSF UI.",
+    action: async () => {
+        await getUiURL();
+    },
+};
+
+async function getUiURL(): Promise<void> {
+    const client = await getApiClient();
+
+    try {
+        const response = await client.get<{ status: string; uiUrl: string }>("/api/global/uiUrl");
+
+        if (response.status === 200 && response.data.status === "OK") {
+            console.log(
+                `${chalk.green("✓")} SHSF UI URL: ${chalk.bgGreen.black(` ${response.data.uiUrl} `)}`
+            );
+        } else {
+            console.log(
+                `${chalk.yellow("!")} SHSF Status: ${chalk.bgYellow.black(" UNEXPECTED RESPONSE ")}`,
+            );
+            console.log(`Status Code: ${chalk.blue(response.status)}`);
+            console.log(`Response Data: ${JSON.stringify(response.data)}`);
+        }
+    } catch (error: any) {
+        if (error.response) {
+            console.error(
+                `${chalk.red("✗")} SHSF Status: ${chalk.bgRed.black(" UNHEALTHY ")}`,
+            );
+            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("✗")} SHSF Status: ${chalk.bgRed.black(" DISCONNECTED ")}`,
+            );
+            console.error(
+                `Error: ${chalk.yellow("Could not connect to the SHSF instance. Check your connection or SHSF_INSTANCE URL.")}`,
+            );
+        } else {
+            console.error(
+                `${chalk.red("✗")} SHSF Status: ${chalk.bgRed.black(" LOCAL ERROR ")}`,
+            );
+            console.error(`Error: ${chalk.yellow(error.message)}`);
+        }
+    }
+}
@@ -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}`);
+      }
+    }
+  },
+};
@@ -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}`);
+      }
+    }
+  },
+};
@@ -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.put(`/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}`);
+      }
+    }
+  },
+};
@@ -0,0 +1,11 @@
+// Minimal API client interface used by this CLI. Keep it small so tests can
+// provide lightweight mocks without implementing the full AxiosInstance.
+export interface ApiClient {
+	get(url: string, config?: any): Promise<{ status: number; data: any }>;
+	put(url: string, payload?: any, config?: any): Promise<{ status: number; data: any }>;
+	delete(url: string, config?: any): Promise<{ status: number; data: any }>;
+	patch(url: string, payload?: any, config?: any): Promise<{ status: number; data: any }>;
+}
+
+export type { ApiClient as ApiClientType };
+
@@ -0,0 +1,42 @@
+export function parseCorsOriginsOption(rawValue: unknown): { corsOrigins?: string[]; error?: string } {
+  if (rawValue === undefined || rawValue === null) {
+    return {};
+  }
+
+  const tokens = Array.isArray(rawValue) ? rawValue : [rawValue];
+  const splitValues = tokens
+    .map((value) => String(value).trim())
+    .flatMap((value) => value.split(","))
+    .map((value) => value.trim())
+    .filter(Boolean);
+
+  if (splitValues.length === 0) {
+    return { error: "No valid values were provided for --cors-origins." };
+  }
+
+  const uniqueOrigins: string[] = [];
+  const seen = new Set<string>();
+
+  for (const origin of splitValues) {
+    let parsed: URL;
+
+    try {
+      parsed = new URL(origin);
+    } catch {
+      return { error: `Invalid CORS origin URL: ${origin}` };
+    }
+
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return { error: `Invalid CORS origin protocol for ${origin}. Only http and https are allowed.` };
+    }
+
+    const normalizedOrigin = parsed.origin;
+
+    if (!seen.has(normalizedOrigin)) {
+      seen.add(normalizedOrigin);
+      uniqueOrigins.push(normalizedOrigin);
+    }
+  }
+
+  return { corsOrigins: uniqueOrigins };
+}
@@ -0,0 +1,85 @@
+import chalk from "chalk";
+import { getApiClient } from "../api.js";
+import { readMappingFile } from "./push_helpers.js";
+import { parseCorsOriginsOption } from "./cors.js";
+
+export function resolveFunctionId(options: { id?: string }): string | null {
+  if (options.id) {
+    return options.id;
+  }
+
+  const mapping = readMappingFile();
+  if (mapping?.id) {
+    console.log(chalk.blue(`Using mapped id ${mapping.id} from .shsf.json`));
+    return mapping.id;
+  }
+
+  console.error(
+    `${chalk.red("✗")} Function ID is required. Use ${chalk.cyan("--id <id>")} or provide an ${chalk.cyan(".shsf.json")} mapping with an ${chalk.cyan("id")}.`,
+  );
+  return null;
+}
+
+export function validateSingleOrigin(origin: string): { origin?: string; error?: string } {
+  const parsed = parseCorsOriginsOption(origin);
+  if (parsed.error) return { error: parsed.error };
+
+  const normalized = parsed.corsOrigins?.[0];
+  if (!normalized) {
+    return { error: "No valid origin provided." };
+  }
+
+  return { origin: normalized };
+}
+
+export function parseCorsOriginsString(corsOriginsRaw: unknown): string[] {
+  if (typeof corsOriginsRaw !== "string") {
+    return [];
+  }
+
+  return corsOriginsRaw
+    .split(",")
+    .map((value) => value.trim())
+    .filter(Boolean);
+}
+
+export async function getFunctionCorsOrigins(functionId: string): Promise<string[]> {
+  const client = await getApiClient();
+  const response = await client.get(`/api/function/${functionId}/cors-origins`);
+
+  const rawValue =
+    response.data?.cors_origins ??
+    response.data?.data?.cors_origins ??
+    response.data?.data ??
+    "";
+
+  return parseCorsOriginsString(rawValue);
+}
+
+export async function setFunctionCorsOrigins(functionId: string, origins: string[]): Promise<void> {
+  const client = await getApiClient();
+  await client.patch(`/api/function/${functionId}/cors-origins`, {
+    cors_origins: origins.join(","),
+  });
+}
+
+export function handleCorsCommandError(error: any, action: string) {
+  if (error.response?.status === 404) {
+    console.error(`${chalk.red("✗")} Function not found.`);
+    return;
+  }
+
+  if (error.response) {
+    console.error(
+      `${chalk.red("✗")} Failed to ${action}: ${chalk.yellow(error.response.data?.message || "Unknown error")}`,
+    );
+    return;
+  }
+
+  if (error.request) {
+    console.error(`${chalk.red("✗")} No response received from server.`);
+    return;
+  }
+
+  console.error(`${chalk.red("✗")} Error: ${error.message}`);
+}
@@ -0,0 +1,63 @@
+import chalk from "chalk";
+import type { ApiClient } from "../types/apiClient.js";
+
+export async function listFiles(client: ApiClient, functionId: string) {
+  const response = await client.get(`/api/function/${functionId}/files`);
+  if (response.status === 200) return response.data.data || [];
+  throw new Error(`Unexpected status ${response.status}`);
+}
+
+export async function createOrUpdateFile(client: ApiClient, functionId: string, filename: string, code: string) {
+  const payload = { filename, code };
+  const response = await client.put(`/api/function/${functionId}/file`, payload);
+  if (response.status === 200 || response.status === 201) return response.data;
+  throw new Error(`Unexpected status ${response.status}`);
+}
+
+export async function deleteFile(client: ApiClient, functionId: string, fileId: string, filename?: string) {
+  // Some endpoints expect filename on body; include if provided.
+  const opts: any = {};
+  if (filename) opts.data = { filename };
+  const response = await client.delete(`/api/function/${functionId}/file/${fileId}`, opts);
+  if (response.status === 200) return true;
+  throw new Error(`Unexpected status ${response.status}`);
+}
+
+export async function renameFile(client: ApiClient, functionId: string, fileId: string, newFilename: string) {
+  const response = await client.patch(
+    `/api/function/${functionId}/file/${fileId}/rename`,
+    { newFilename },
+  );
+  if (response.status === 200) return response.data;
+  throw new Error(`Unexpected status ${response.status}`);
+}
+
+export function handleAxiosError(error: any) {
+  if (error.response) {
+    // If the server signals a CLI file failure, stop further commands.
+    if (error.response.data?.cli_file_fail) {
+      console.error(`${chalk.red("✗")} ${error.response.data.message || "File operation blocked by server. (Probably because git is configured)"}`);
+      return { errorType: "cli_file_fail", reason: error.response.data.cli_file_fail, details: error.response };
+    }
+    if (error.response.status === 404) {
+      console.error(`${chalk.red("✗")} Not found.`);
+      return { errorType: "notfound" };
+    }
+    console.error(`${chalk.red("✗")} ${error.response.data?.message || error.response.statusText}`);
+    return { errorType: "response", details: error.response };
+  }
+  if (error.request) {
+    console.error(`${chalk.red("✗")} No response received from server.`);
+    return { errorType: "norequest" };
+  }
+  console.error(`${chalk.red("✗")} Error: ${error.message}`);
+  return { errorType: "other" };
+}
+
+export default {
+  listFiles,
+  createOrUpdateFile,
+  deleteFile,
+  renameFile,
+  handleAxiosError,
+};
@@ -0,0 +1,98 @@
+import fs from "fs";
+import path from "path";
+
+export const defaultUnpushableFiles = [
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".7z",
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".ppt",
+  ".pptx",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  "docker-compose.yml",
+  "docker-compose.yaml",
+  "compose.yaml",
+  "compose.yml",
+  "dockerfile",
+  "dockerfile.dev",
+  "dockerfile.prod",
+  ".gitignore",
+  ".env",
+  ".gitkeep",
+  ".md",
+];
+
+export function readIgnoreFile(dir: string): string[] {
+  const candidates = [path.join(dir, ".shsfignore"), path.join(process.cwd(), ".shsfignore")];
+  for (const p of candidates) {
+    if (fs.existsSync(p)) {
+      try {
+        return fs
+          .readFileSync(p, "utf-8")
+          .split(/\r?\n/)
+          .map((l) => l.trim())
+          .filter((l) => l && !l.startsWith("#"));
+      } catch (_err) {
+        return [];
+      }
+    }
+  }
+  return [];
+}
+
+function globToRegExp(pattern: string): RegExp {
+  let p = pattern.trim();
+  if (!p.includes("*")) {
+    if (!p.startsWith("/")) {
+      p = `*${p}`;
+    }
+  }
+  // Escape regex special chars, then replace * with .*
+  const escaped = p.replace(/[-\/\\^$+?.()|[\]{}]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`, "i");
+}
+
+export function matchesAnyPattern(filename: string, patterns: string[]): boolean {
+  const name = filename.replace(/\\/g, "/");
+  for (const pat of patterns) {
+    try {
+      const re = globToRegExp(pat);
+      if (re.test(name)) return true;
+    } catch (_e) {
+      if (name.toLowerCase().endsWith(pat.toLowerCase())) return true;
+    }
+  }
+  return false;
+}
+
+export function readMappingFile(cwd?: string): { id?: string; from?: string } | null {
+  const base = cwd || process.cwd();
+  const p = path.join(base, ".shsf.json");
+  if (!fs.existsSync(p)) return null;
+  try {
+    const raw = fs.readFileSync(p, "utf-8");
+    const json = JSON.parse(raw);
+    if (json && typeof json === "object") {
+      return (json.default || json) as { id?: string; from?: string };
+    }
+  } catch (_e) {
+    // ignore
+  }
+  return null;
+}
+
+export default null;
@@ -0,0 +1,13 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    exclude: ['**/node_modules/**', '**/dist/**', '**/cypress/**', '**/.{idea,git,cache,output,temp}/**'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+    }
+  },
+});
Author	SHA1	Message	Date
Space-Banane	544f6bd714	feat(cors): implement CORS management commands and utilities	2026-04-14 22:38:27 +02:00
Space-Banane	c912c791fa	Added coding docs from shsf to shsf-cli	2026-04-14 18:23:11 +02:00
Space-Banane	d9d6871f09	bump version	2026-04-14 18:13:35 +02:00
Space-Banane	121b0429f6	fix(cli): use PUT for trigger updates to match OpenAPI spec	2026-04-14 18:11:13 +02:00
Space-Banane	9f78e2a221	fix: update version number to 2.2.9 in package.json and correct API endpoint in createNamespaceDefinition	2026-04-14 17:55:09 +02:00
Space-Banane	1a0e811a9a	fix: update version number to 2.2.8 in package.json	2026-04-05 17:50:59 +02:00
Space-Banane	57b05da8c1	feat: enhance error handling for CLI file failures in handleAxiosError function	2026-04-05 17:49:40 +02:00
Space-Banane	e6e2203751	feat: refactor file operations and add utility functions for file management	2026-04-05 17:46:38 +02:00
Space-Banane	5c18138dd2	fix: update version number to 2.2.7 in package.json	2026-04-03 17:51:23 +02:00
Space-Banane	9f2d72c3a0	feat: implement file ignore and mapping functionality for remote push command	2026-04-03 17:48:44 +02:00
Space-Banane	dddb352457	Added some more unpushable files (for now)	2026-04-01 17:28:42 +02:00
Space-Banane	3fe3dc96da	fix: update version number to 2.2.5 in package.json and enhance file reading logic in push command	2026-04-01 17:24:42 +02:00
Space-Banane	e953466786	fix: update version number to 2.2.4 in package.json	2026-04-01 13:03:58 +02:00
Space-Banane	c43c37ce34	feat: add unpushable file checks to prevent uploading certain file types	2026-04-01 13:01:47 +02:00
Space-Banane	13900343a3	feat: add commands for managing environment variables in functions & removed ui docs from skill	2026-03-27 17:18:00 +01:00
Space-Banane	cc54ef85e1	fix: update command syntax for function execution in documentation	2026-03-27 16:56:54 +01:00
Space-Banane	67f05af7a5	feat: add execute command for function execution with streaming options	2026-03-27 16:55:28 +01:00
Space-Banane	37f6d50034	fix: requirements.txt modifications	2026-03-27 16:50:04 +01:00
Space-Banane	a1f80d38f2	update skill to reflect changes	2026-03-27 16:38:18 +01:00
Space-Banane	7b659b1ef5	version-bump: commit of shame	2026-03-27 16:36:48 +01:00
Space-Banane	3261cc1830	unslopped file operations	2026-03-27 16:35:43 +01:00
Space	a76bb15fc9	feat: add req subcommands for managing requirements.txt (#5 ) * feat: add req subcommands for managing requirements.txt * bump: version 2.1.9 * fix: address codex review comments (flag consistency, regex-based pkg parsing, error handling) --------- Co-authored-by: Luna <clawy@reversed.dev>	2026-03-26 14:01:15 +01:00
Space	47cd88f72b	feat: log byte count for push and pull	2026-03-20 18:01:29 +01:00
luna	6a98ef4bed	feat: log byte count for push and pull, increment version	2026-03-20 17:59:41 +01:00
Space	e6dea43555	Add remote sync commands	2026-03-20 17:03:45 +01:00
Space-Banane	7b86fec717	That should do	2026-03-20 17:02:34 +01:00
Space-Banane	0be63e5287	Fixed spacing	2026-03-20 16:28:37 +01:00
luna	1d04649cbf	Refactor remote commands into remote subdirectory	2026-03-20 16:24:09 +01:00
luna	344e10ac46	Add remote sync command and tests	2026-03-20 16:21:53 +01:00
Space-Banane	6ad74bb991	feat: add testing using vitest	2026-03-20 14:56:19 +01:00
Space-Banane	1b3851d0af	docs: emphasize the use of pnpm for package updates	2026-03-20 09:00:39 +01:00
luna	9887ca3dcc	chore: bump version to 2.1.5 and add versioning policy	2026-03-20 08:58:03 +01:00
luna	ae82ba221b	fix: improve error handling for pipinstall	2026-03-20 08:55:10 +01:00
luna	8428ed56b5	feat: add pipinstall command	2026-03-20 08:51:29 +01:00
Space-Banane	20d34bf6e7	add: Implement storage management commands including create, delete, list, and item manipulation	2026-03-18 22:35:18 +01:00
Space-Banane	11a239dbf4	refactor: Remove unnecessary heading for count commands in documentation	2026-03-18 18:41:15 +01:00
Space-Banane	342b8dd61f	add: Implement UI URL command and update documentation with UI links and routes	2026-03-18 18:00:35 +01:00
Space-Banane	625e3e2a3e	add: Updating instructions for skill	2026-03-18 17:08:39 +01:00
Space-Banane	ec06127443	Enhance CI/CD workflow by specifying paths for push and pull request triggers; update documentation with installation instructions and feature update reminders.	2026-03-18 17:05:40 +01:00
Space-Banane	f8730b2044	Mass Implement of basic features	2026-03-18 17:02:30 +01:00
Space-Banane	9aec36d0e8	Implemented count feature	2026-03-18 16:33:03 +01:00