5.0.5

fix(coreflow): Fix Coreflow identity lookup and response shape; improve API client tests and bump dependencies
Enhance README for @serve.zone/interfaces: improve structure, add features, and clarify installation instructions
2025-08-18 21:11:28 +00:00 · 2025-08-18 21:11:28 +00:00 · 2025-08-18 03:16:28 +00:00 · 2025-08-18 03:14:49 +00:00 · 2025-08-18 03:07:12 +00:00 · 2025-04-25 18:20:18 +00:00
21 changed files with 7173 additions and 5388 deletions
--- a/changelog.md
+++ b/changelog.md
@@ -1,5 +1,49 @@
 # Changelog
 ## 2025-08-18 - 5.0.5 - fix(coreflow)
 Fix Coreflow identity lookup and response shape; improve API client tests and bump dependencies
 - ts/manager.coreflow/coreflowmanager.ts: Use $elemMatch to correctly query nested user.tokens when resolving identities and validate machine user types.
 - ts/manager.coreflow/coreflowmanager.ts: Normalize getClusterConfig response to include services (was deploymentDirectives) and tidy handler signatures.
 - test/test.apiclient.ts: Add detailed logging and improved error handling across preTask, client startup, identity retrieval, image creation and image upload to aid debugging and test observability.
 - package.json: Update dependency versions (notable bumps): @types/node -> ^22.0.0, @push.rocks/smartacme -> ^8.0.0, @push.rocks/smartdata -> ^5.16.4, @push.rocks/smartexpect -> ^2.5.0, @push.rocks/smartpath -> ^6.0.0, @push.rocks/smartrequest -> ^4.2.2, plus other maintenance bumps.
 - Add .claude/settings.local.json to provide local Claude permissions for developer tooling.
 ## 2025-04-25 - 5.0.4 - fix(platformservice/mta)
 Update getEmailStatus response schema: make details property optional
 - Changed details property from required with fixed message to optional with a flexible message structure in IReq_GetEMailStats response
 ## 2025-04-25 - 5.0.3 - fix(mta)
 update email status response type in MTA platform service
 - Changed the response 'status' field in IRequest_CheckEmailStatus from a literal 'unknown' to a generic string for improved flexibility
 ## 2025-04-25 - 5.0.2 - fix(platformservice/mta)
 Refactor email status response in MTA service
 - Updated IReq_CheckEmailStatus response: replaced union type ('ok' | 'not ok') with fixed status 'unknown' and added a details object with message 'Email not found'.
 ## 2025-04-25 - 5.0.1 - fix(mta)
 Update email stats response interface in mta platform service to include totalEmailsSent, totalEmailsDelivered, totalEmailsBounced, averageDeliveryTimeMs, and lastUpdated timestamp.
 - Modified IReq_GetEMailStats response in ts_interfaces/platformservice/mta.ts from an empty status object to a detailed email statistics structure.
 ## 2025-04-25 - 5.0.0 - BREAKING CHANGE(ts_interfaces/platformservice/mta)
 Rename mta interfaces and upgrade dependency versions
 - Upgraded devDependencies: @git.zone/tsbuild, tsbundle, tsdoc, tstest, tswatch, and @push.rocks/tapbundle to newer versions.
 - Upgraded dependencies: @design.estate/dees-catalog, dees-domtools, dees-element, @push.rocks/smartdata, smartexpect, smartfile, smartpromise, smartrequest, smartrx, and tsclass (v4.2.0 to v9.0.0).
 - Added new packageManager field in package.json and introduced pnpm-workspace.yaml for additional workspace configuration.
 - Refactored mta API interfaces: renamed IRequest_SendEmail to IReq_SendEmail and IRequestRegisterRecipient to IReq_RegisterRecipient; added IReq_CheckEmailStatus and IReq_GetEMailStats.
 ## 2025-01-20 - 4.13.0 - feat(service)
 Add support for service creation, update, and deletion.
 - Implemented TypedHandlers for creating a new service.
 - Added features to update existing service details.
 - Enabled deletion of services by their unique ID.
 ## 2025-01-20 - 4.12.2 - fix(service)
 Fix secret bundle and service management bugs
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@serve.zone/cloudly",
-  "version": "4.12.2",
+  "version": "5.0.5",
  "private": false,
  "description": "A comprehensive tool for managing containerized applications across multiple cloud providers using Docker Swarmkit, featuring web, CLI, and API interfaces.",
  "type": "module",
@@ -13,7 +13,7 @@
  "author": "Task Venture Capital GmbH",
  "license": "MIT",
  "scripts": {
-    "test": "(tstest test/)",
+    "test": "(tstest test/ --verbose --logfile --timeout 120)",
    "build": "tsbuild tsfolders --web --allowimplicitany && tsbundle website --production",
    "start": "node cli.js",
    "startTs": "node cli.ts.js",
@@ -22,59 +22,58 @@
    "docs": "tsdoc aidoc"
  },
  "devDependencies": {
-    "@git.zone/tsbuild": "^2.2.0",
+    "@git.zone/tsbuild": "^2.6.7",
-    "@git.zone/tsbundle": "^2.1.0",
+    "@git.zone/tsbundle": "^2.5.1",
-    "@git.zone/tsdoc": "^1.4.2",
+    "@git.zone/tsdoc": "^1.5.1",
-    "@git.zone/tspublish": "^1.9.1",
+    "@git.zone/tspublish": "^1.10.3",
-    "@git.zone/tstest": "^1.0.90",
+    "@git.zone/tstest": "^2.3.5",
-    "@git.zone/tswatch": "^2.0.37",
+    "@git.zone/tswatch": "^2.2.1",
-    "@push.rocks/tapbundle": "^5.5.4",
+    "@types/node": "^22.0.0"
    "@types/node": "^22.10.3"
  },
  "dependencies": {
    "@api.global/typedrequest": "3.1.10",
    "@api.global/typedrequest-interfaces": "^3.0.19",
-    "@api.global/typedserver": "^3.0.53",
+    "@api.global/typedserver": "^3.0.77",
    "@api.global/typedsocket": "^3.0.1",
-    "@apiclient.xyz/cloudflare": "^6.0.1",
+    "@apiclient.xyz/cloudflare": "^6.4.1",
    "@apiclient.xyz/docker": "^1.3.0",
    "@apiclient.xyz/hetznercloud": "^1.2.0",
    "@apiclient.xyz/slack": "^3.0.9",
-    "@design.estate/dees-catalog": "^1.3.3",
+    "@design.estate/dees-catalog": "^1.10.10",
-    "@design.estate/dees-domtools": "^2.0.64",
+    "@design.estate/dees-domtools": "^2.3.3",
-    "@design.estate/dees-element": "^2.0.39",
+    "@design.estate/dees-element": "^2.1.2",
    "@git.zone/tsrun": "^1.3.3",
    "@push.rocks/early": "^4.0.3",
-    "@push.rocks/npmextra": "^5.1.2",
+    "@push.rocks/npmextra": "^5.3.3",
    "@push.rocks/projectinfo": "^5.0.1",
-    "@push.rocks/qenv": "^6.1.0",
+    "@push.rocks/qenv": "^6.1.3",
-    "@push.rocks/smartacme": "^5.0.0",
+    "@push.rocks/smartacme": "^8.0.0",
-    "@push.rocks/smartbucket": "^3.3.7",
+    "@push.rocks/smartbucket": "^3.3.10",
    "@push.rocks/smartcli": "^4.0.11",
    "@push.rocks/smartclickhouse": "^2.0.17",
-    "@push.rocks/smartdata": "^5.2.10",
+    "@push.rocks/smartdata": "^5.16.4",
    "@push.rocks/smartdelay": "^3.0.5",
    "@push.rocks/smartexit": "^1.0.23",
-    "@push.rocks/smartexpect": "^1.4.0",
+    "@push.rocks/smartexpect": "^2.5.0",
-    "@push.rocks/smartfile": "^11.0.23",
+    "@push.rocks/smartfile": "^11.2.7",
    "@push.rocks/smartguard": "^3.1.0",
    "@push.rocks/smartjson": "^5.0.19",
    "@push.rocks/smartjwt": "^2.2.1",
-    "@push.rocks/smartlog": "^3.0.7",
+    "@push.rocks/smartlog": "^3.1.8",
    "@push.rocks/smartlog-destination-clickhouse": "^1.0.13",
    "@push.rocks/smartlog-interfaces": "^3.0.2",
-    "@push.rocks/smartpath": "^5.0.18",
+    "@push.rocks/smartpath": "^6.0.0",
-    "@push.rocks/smartpromise": "^4.0.4",
+    "@push.rocks/smartpromise": "^4.2.3",
-    "@push.rocks/smartrequest": "^2.0.23",
+    "@push.rocks/smartrequest": "^4.2.2",
-    "@push.rocks/smartrx": "^3.0.7",
+    "@push.rocks/smartrx": "^3.0.10",
    "@push.rocks/smartssh": "^2.0.1",
-    "@push.rocks/smartstate": "^2.0.19",
+    "@push.rocks/smartstate": "^2.0.26",
    "@push.rocks/smartstream": "^3.2.5",
    "@push.rocks/smartstring": "^4.0.15",
    "@push.rocks/smartunique": "^3.0.9",
    "@push.rocks/taskbuffer": "^3.0.2",
    "@push.rocks/webjwt": "^1.0.9",
-    "@tsclass/tsclass": "^4.2.0"
+    "@tsclass/tsclass": "^9.2.0"
  },
  "files": [
    "ts/**/*",
@@ -126,5 +125,6 @@
    "frontend",
    "backend",
    "security"
-  ]
+  ],
  "packageManager": "pnpm@10.7.0+sha512.6b865ad4b62a1d9842b61d674a393903b871d9244954f652b8842c2b553c72176b278f64c463e52d40fff8aba385c235c8c9ecf5cc7de4fd78b8bb6d49633ab6"
 }
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -0,0 +1,4 @@
 onlyBuiltDependencies:
  - esbuild
  - mongodb-memory-server
  - puppeteer
--- a/readme.hints.md
+++ b/readme.hints.md
@@ -9,3 +9,11 @@
 - Note: the exports are defined in the package.json.
 - For now, cloud wise only the setup with cloudron and hetzner cloud is supported.
 ## Architecture Overview
 - serve.zone is a monorepo containing multiple packages that work together to provide a complete container orchestration platform
 - Uses Docker Swarm as the underlying container orchestration technology
 - cloudly acts as the control plane providing API, web UI, and CLI interfaces
 - coreflow runs inside Docker Swarm clusters to manage containers
 - coretraffic runs on each node to handle traffic routing and SSL
 - spark manages individual servers at the OS level
--- a/readme.md
+++ b/readme.md
@@ -1,335 +1,242 @@
-# @serve.zone/cloudly
+# @serve.zone/cloudly 🚀
-A multi-cloud management tool utilizing Docker Swarmkit for orchestrating containerized apps across various cloud providers, with web, CLI, and API interfaces for configuration and integration management.
+**Multi-cloud orchestration made simple.** Manage containerized applications across cloud providers with Docker Swarmkit, featuring web dashboards, CLI tools, and powerful APIs.
-## Install
+## 🎯 What is Cloudly?
-To install `@serve.zone/cloudly`, run the following command in your terminal:
+Cloudly is your command center for multi-cloud infrastructure. It abstracts away the complexity of managing resources across different cloud providers while giving you the power and flexibility you need for modern DevOps workflows.
 ### ✨ Key Features
 - **🌐 Multi-Cloud Management** - Seamlessly orchestrate resources across Cloudflare, Hetzner, DigitalOcean and more
 - **🐳 Docker Swarmkit Integration** - Native container orchestration with production-grade reliability
 - **🔐 Secret Management** - Secure handling of credentials, API keys, and sensitive configuration
 - **🎨 Web Dashboard** - Beautiful, responsive UI built with modern web components
 - **⚡ CLI & API** - Full programmatic control through TypeScript/JavaScript APIs and command-line tools
 - **🔒 SSL/TLS Automation** - Automatic certificate provisioning via Let's Encrypt
 - **📊 Comprehensive Logging** - Built-in log aggregation and monitoring capabilities
 - **🔄 Task Scheduling** - Automated workflows and background job management
 ## 🚀 Quick Start
 ### Installation
 ```bash
-npm install @serve.zone/cloudly --save
+# Install the main package
 pnpm add @serve.zone/cloudly
 # Or install the CLI globally
 pnpm add -g @serve.zone/cli
 # Or just the API client
 pnpm add @serve.zone/api
 ```
 This will install the package and add it to your project's `package.json` dependencies.
 ## Usage
 `@serve.zone/cloudly` is designed to provide a unified interface for managing multi-cloud environments, encapsulating complex cloud interactions with Docker Swarmkit into simpler, programmable entities. This document will guide you through various use-cases and implementation examples to give you a comprehensive understanding of the module's capabilities.
 ### Prerequisites
 Before you begin, ensure your environment is set up correctly:
 - You have Node.js installed (preferably the latest LTS version).
 - Your environment is configured to use TypeScript if you're working in a TypeScript project.
 ### Basic Setup
 #### Creating a Cloudly Instance
 The foundation of working with `@serve.zone/cloudly` involves creating an instance of the `Cloudly` class. This instance serves as the gateway to managing cloud resources and orchestrates interactions within the platform. Here’s how to get started:
 ```typescript
 import { Cloudly, ICloudlyConfig } from '@serve.zone/cloudly';
 const myCloudlyConfig: ICloudlyConfig = {
    cfToken: 'your_cloudflare_api_token',
    hetznerToken: 'your_hetzner_api_token',
    environment: 'development',
    letsEncryptEmail: 'lets_encrypt_email@example.com',
    publicUrl: 'example.com',
    publicPort: '8443',
    mongoDescriptor: {
        mongoDbUrl: 'mongodb+srv://<username>:<password>@<cluster>.mongodb.net/myFirstDatabase',
        mongoDbName: 'myDatabase',
        mongoDbUser: 'myUser',
        mongoDbPass: 'myPassword',
    },
 };
 const myCloudlyInstance = new Cloudly(myCloudlyConfig);
 ```
 The configuration object `ICloudlyConfig` provides essential information needed for initializing external services, such as Cloudflare, Hetzner, and a MongoDB server. Adjust the parameters to match your actual service credentials and specifications.
 ### Core Features and Use Cases
 #### Orchestrating Docker Swarmkit Clusters
 Docker Swarmkit cluster management is a primary feature of `@serve.zone/cloudly`. Through its abstracted, programmable interface, you can operate clusters effortlessly. Here’s an example of how to create a cluster using `Cloudly`:
 ```typescript
 import { Cloudly } from '@serve.zone/cloudly';
-interface ICluster {
+// Initialize Cloudly with your configuration
-    name: string;
+const cloudly = new Cloudly({
-    id: string;
+  cfToken: process.env.CLOUDFLARE_TOKEN,
-    cloudlyUrl: string;
+  hetznerToken: process.env.HETZNER_TOKEN,
-    servers: string[];
+  environment: 'production',
-    sshKeys: string[];
+  letsEncryptEmail: 'certs@example.com',
-}
+  publicUrl: 'cloudly.example.com',
-
+  publicPort: 443,
 async function manageClusters() {
    const myCloudlyConfig = {
        cfToken: 'your_cloudflare_api_token',
        environment: 'development',
  mongoDescriptor: {
-            mongoDbUrl: 'mongodb+srv://<username>:<password>@<cluster>.mongodb.net/myFirstDatabase',
+    mongoDbUrl: process.env.MONGODB_URL,
-            mongoDbName: 'myDatabase',
+    mongoDbName: 'cloudly',
-            mongoDbUser: 'myUser',
+    mongoDbUser: process.env.MONGODB_USER,
-            mongoDbPass: 'myPassword',
+    mongoDbPass: process.env.MONGODB_PASS,
-        },
+  }
-        letsEncryptEmail: 'lets_encrypt_email@example.com',
+});
        publicUrl: 'example.com',
        publicPort: 8443,
        hetznerToken: 'your_hetzner_api_token',
    };
-    const myCloudlyInstance = new Cloudly(myCloudlyConfig);
+// Start the platform
-    await myCloudlyInstance.start();
+await cloudly.start();
-
+console.log('🎉 Cloudly is running!');
    const newCluster: ICluster = {
        name: 'example_cluster',
        id: 'example_cluster_id',
        cloudlyUrl: 'https://example.com:8443',
        servers: [],
        sshKeys: [],
    };
    // Store the newly created cluster with Cloudly
    const storedCluster = await myCloudlyInstance.clusterManager.storeCluster(newCluster);
    console.log('Cluster stored:', storedCluster);
 }
 manageClusters();
 ```
-In this scenario, a cluster called `example_cluster` is initialized using the `Cloudly` instance. This method represents a central mechanism to efficiently handle cluster entities and associated metadata.
+## 🏗️ Architecture
-#### Integrating With Cloudflare for DNS Management
+Cloudly follows a modular architecture with clear separation of concerns:
-`@serve.zone/cloudly` provides built-in capabilities for managing DNS records through integration with Cloudflare. Using the `CloudflareConnector`, you can programmatically create, manage, and delete DNS entries:
+```
 ┌─────────────────────────────────────────────┐
 │             Web Dashboard (UI)              │
 ├─────────────────────────────────────────────┤
 │          API Layer (TypedRouter)            │
 ├─────────────────────────────────────────────┤
 │              Core Managers                  │
 │  ┌─────────┐ ┌─────────┐ ┌─────────┐        │
 │  │ Cluster │ │  Image  │ │ Secret  │ ...    │
 │  └─────────┘ └─────────┘ └─────────┘        │
 ├─────────────────────────────────────────────┤
 │            Cloud Connectors                 │
 │  ┌──────────┐ ┌─────────┐ ┌──────────----┐  │
 │  │Cloudflare│ │ Hetzner │ │ DigitalOcean │  │
 │  └──────────┘ └─────────┘ └──────────----┘  │
 └─────────────────────────────────────────────┘
 ```
 ## 💻 Core Components
 ### 🔧 Managers
 - **AuthManager** - Identity and access management
 - **ClusterManager** - Docker Swarm cluster orchestration  
 - **ImageManager** - Container image lifecycle management
 - **SecretManager** - Secure credential storage and distribution
 - **ServerManager** - Cloud server provisioning and management
 - **TaskManager** - Background job scheduling and execution
 ### 🔌 Connectors
 - **CloudflareConnector** - DNS, CDN, and edge services
 - **LetsencryptConnector** - Automatic SSL certificate provisioning
 - **MongodbConnector** - Database persistence layer
 - **HetznerConnector** - German cloud infrastructure
 - **DigitalOceanConnector** - Developer-friendly cloud resources
 ## 📚 Usage Examples
 ### Managing Clusters
 ```typescript
-import { Cloudly } from '@serve.zone/cloudly';
+// Create a new cluster
 const cluster = await cloudly.clusterManager.createCluster({
  name: 'production-cluster',
  region: 'eu-central',
  nodeCount: 3
 });
-async function configureCloudflareDNS() {
+// Deploy a service
-    const myCloudlyConfig = {
+await cluster.deployService({
-        cfToken: 'your_cloudflare_api_token',
+  name: 'api-service',
-        environment: 'development',
+  image: 'myapp:latest',
-        letsEncryptEmail: 'lets_encrypt_email@example.com',
+  replicas: 3,
-        publicUrl: 'example.com',
+  ports: [{ published: 80, target: 3000 }]
-        publicPort: 8443,
+});
        hetznerToken: 'your_hetzner_api_token',
        mongoDescriptor: {
            mongoDbUrl: 'mongodb+srv://<username>:<password>@<cluster>.mongodb.net/myFirstDatabase',
            mongoDbName: 'myDatabase',
            mongoDbUser: 'myUser',
            mongoDbPass: 'myPassword',
        },
    };
    const myCloudlyInstance = new Cloudly(myCloudlyConfig);
    await myCloudlyInstance.start();
    const cfConnector = myCloudlyInstance.cloudflareConnector.cloudflare;
    const dnsRecord = await cfConnector.createDNSRecord('example.com', 'sub.example.com', 'A', '127.0.0.1');
    console.log('DNS Record:', dnsRecord);
 }
 configureCloudflareDNS();
 ```
-Here, you create an A record for the subdomain `sub.example.com` pointing to `127.0.0.1`. All communication with Cloudflare is handled directly through the interface without manual intervention.
+### Secret Management
 #### Dynamic Interaction with DigitalOcean
 DigitalOcean resource management, including droplet creation, is simplified in Cloudly. By extending the API to encapsulate calls to external providers, Cloudly provides a seamless experience:
 ```typescript
-import { Cloudly } from '@serve.zone/cloudly';
+// Create a secret group
 const secretGroup = await cloudly.secretManager.createSecretGroup({
  name: 'api-credentials',
  secrets: [
    { key: 'API_KEY', value: process.env.API_KEY },
    { key: 'DB_PASSWORD', value: process.env.DB_PASSWORD }
  ]
 });
-async function createDigitalOceanDroplets() {
+// Create a bundle for deployment
-    const myCloudlyConfig = {
+const bundle = await cloudly.secretManager.createSecretBundle({
-        cfToken: 'your_cloudflare_api_token',
+  name: 'production-secrets',
-        environment: 'development',
+  secretGroups: [secretGroup]
-        letsEncryptEmail: 'lets_encrypt_email@example.com',
+});
        publicUrl: 'example.com',
        publicPort: 8443,
        hetznerToken: 'your_hetzner_api_token',
        mongoDescriptor: {
            mongoDbUrl: 'mongodb+srv://<username>:<password>@<cluster>.mongodb.net/myFirstDatabase',
            mongoDbName: 'myDatabase',
            mongoDbUser: 'myUser',
            mongoDbPass: 'myPassword',
        },
    };
    const myCloudlyInstance = new Cloudly(myCloudlyConfig);
    await myCloudlyInstance.start();
    const doConnector = myCloudlyInstance.digitaloceanConnector;
    const droplet = await doConnector.createDroplet('example-droplet', 'nyc3', 's-1vcpu-1gb', 'ubuntu-20-04-x64');
    console.log('Droplet created:', droplet);
 }
 createDigitalOceanDroplets();
 ```
-In this script, a droplet named `example-droplet` is created within the `nyc3` region using the `ubuntu-20-04-x64` image. The module abstracts complexities by directly interfacing with DigitalOcean.
+### DNS Management
-### Advanced Use Cases
+```typescript
 // Create DNS records via Cloudflare
 const record = await cloudly.cloudflareConnector.createDNSRecord(
  'example.com',
  'api.example.com', 
  'A',
  '192.168.1.1'
 );
 ```
-#### Implementing Web Management Interface
+### Web Dashboard
 `@serve.zone/cloudly` facilitates dashboard management with advanced Web Components built with `@design.estate`. This section of the library allows the creation of dynamic, interactive panels for real-time resource management in a modern browser interface.
 ```typescript
 import { html } from '@design.estate/dees-element';
-const renderDashboard = () => {
+// Create a custom dashboard view
-    return html`
+const dashboard = html`
  <cloudly-dashboard>
            <dees-simple-appdash>
                <!-- Define sections and elements -->
    <cloudly-view-clusters></cloudly-view-clusters>
    <cloudly-view-dns></cloudly-view-dns>
    <cloudly-view-images></cloudly-view-images>
                <!-- Other custom views -->
            </dees-simple-appdash>
  </cloudly-dashboard>
-    `;
+`;
 };
-document.body.appendChild(renderDashboard());
+document.body.appendChild(dashboard);
 ```
-Utilizing the custom web components designed specifically for Cloudly, dashboards are adaptable, interactive, and maintainable. These elements allow you to structure a complete cloud management center without needing to delve into detailed UI engineering.
+## 🛠️ CLI Usage
-#### Comprehensive Log Management
+The CLI provides quick access to all Cloudly features:
-With Cloudly’s Log Management capabilities, you can track and analyze system logs for better insights into your cloud ecosystem’s behavior:
+```bash
 # Login to your Cloudly instance
 servezone login --url https://cloudly.example.com
-```typescript
+# List clusters
-import { Cloudly } from '@serve.zone/cloudly';
+servezone clusters list
-async function initiateLogManagement() {
+# Deploy a service
-    const myCloudlyConfig = {
+servezone deploy --cluster prod --image myapp:latest
        cfToken: 'your_cloudflare_api_token',
        environment: 'development',
        letsEncryptEmail: 'lets_encrypt_email@example.com',
        publicUrl: 'example.com',
        publicPort: 8443,
        hetznerToken: 'your_hetzner_api_token',
        mongoDescriptor: {
            mongoDbUrl: 'mongodb+srv://<username>:<password>@<cluster>.mongodb.net/myFirstDatabase',
            mongoDbName: 'myDatabase',
            mongoDbUser: 'myUser',
            mongoDbPass: 'myPassword',
        },
    };
-    const myCloudlyInstance = new Cloudly(myCloudlyConfig);
+# Manage secrets
-    await myCloudlyInstance.start();
+servezone secrets create --name api-key --value "secret123"
-    const logs = await myCloudlyInstance.logManager.fetchLogs();
+# View logs
-    console.log('Logs:', logs);
+servezone logs --service api-service --follow
 }
 initiateLogManagement();
 ```
-Cloudly provides the tools needed to collect and process logs within your cloud infrastructure. Logs are an essential part of system validation, troubleshooting, monitoring, and auditing.
+## 📦 Package Exports
-#### Secret Management and Bundles
+This monorepo publishes multiple packages:
-Managing secrets securely and efficiently is critical for cloud operations. Cloudly allows you to create and manage secret groups and bundles that can be used across multiple applications and environments:
+- **@serve.zone/cloudly** - Main orchestration platform
 - **@serve.zone/api** - TypeScript/JavaScript API client
 - **@serve.zone/cli** - Command-line interface
 - **@serve.zone/interfaces** - Shared TypeScript interfaces
-```typescript
+## 🔒 Security Features
 import { Cloudly } from '@serve.zone/cloudly';
-async function createSecrets() {
+- **End-to-end encryption** for secrets
-    const myCloudlyConfig = {
+- **Role-based access control** (RBAC)
-        cfToken: 'your_cloudflare_api_token',
+- **Automatic SSL/TLS** certificate management
-        environment: 'development',
+- **Secure token-based authentication**
-        letsEncryptEmail: 'lets_encrypt_email@example.com',
+- **Audit logging** for compliance
        publicUrl: 'example.com',
        publicPort: 8443,
        hetznerToken: 'your_hetzner_api_token',
        mongoDescriptor: {
            mongoDbUrl: 'mongodb+srv://<username>:<password>@<cluster>.mongodb.net/myFirstDatabase',
            mongoDbName: 'myDatabase',
            mongoDbUser: 'myUser',
            mongoDbPass: 'myPassword',
        },
    };
-    const myCloudlyInstance = new Cloudly(myCloudlyConfig);
+## 🚢 Production Ready
    await myCloudlyInstance.start();
-    const newSecretGroup = await myCloudlyInstance.secretManager.createSecretGroup({
+Cloudly is battle-tested in production environments managing:
-        name: 'example_secret_group',
+- High-traffic web applications
-        secrets: [
+- Microservice architectures
-            { key: 'SECRET_KEY', value: 's3cr3t' },
+- CI/CD pipelines
-        ],
+- Data processing workloads
-    });
+- Real-time communication systems
-    const newSecretBundle = await myCloudlyInstance.secretManager.createSecretBundle({
+## 🤝 Development
        name: 'example_bundle',
        secretGroups: [newSecretGroup],
    });
-    console.log('Created Secret Group and Bundle:', newSecretGroup, newSecretBundle);
+```bash
-}
+# Clone the repository
 git clone https://gitlab.com/servezone/private/cloudly.git
-createSecrets();
+# Install dependencies
 pnpm install
 # Run tests
 pnpm test
 # Build the project
 pnpm build
 # Start development mode
 pnpm watch
 ```
-Secrets, such as API keys and sensitive configuration data, are managed efficiently using secret groups and bundles. This structured approach to secret management enhances both security and accessibility.
+## 📖 Documentation
-### Task Scheduling and Management
+For detailed documentation, API references, and guides, visit our [documentation site](https://cloudly.serve.zone).
 With task buffers, you can schedule and manage background tasks integral to cloud operations:
 ```typescript
 import { Cloudly } from '@serve.zone/cloudly';
 import { TaskBuffer } from '@push.rocks/taskbuffer';
 async function scheduleTasks() {
    const myCloudlyConfig = {
        cfToken: 'your_cloudflare_api_token',
        environment: 'development',
        letsEncryptEmail: 'lets_encrypt_email@example.com',
        publicUrl: 'example.com',
        publicPort: 8443,
        hetznerToken: 'your_hetzner_api_token',
        mongoDescriptor: {
            mongoDbUrl: 'mongodb+srv://<username>:<password>@<cluster>.mongodb.net/myFirstDatabase',
            mongoDbName: 'myDatabase',
            mongoDbUser: 'myUser',
            mongoDbPass: 'myPassword',
        },
    };
    const myCloudlyInstance = new Cloudly(myCloudlyConfig);
    await myCloudlyInstance.start();
    const taskManager = new TaskBuffer();
    taskManager.scheduleEvery('minute', async () => {
        console.log('Running scheduled task...');
        // Task logic
    });
    console.log('Tasks scheduled.');
 }
 scheduleTasks();
 ```
 The example demonstrates setting up periodic task execution using task buffers as part of Cloudly's task management. Whether it's maintenance routines, data updates, or resource checks, tasks can be managed effectively.
 This comprehensive overview of `@serve.zone/cloudly` is designed to help you leverage its full capabilities in managing multi-cloud environments. Each example is meant to serve as a starting point, and you are encouraged to explore further by consulting the relevant sections in the documentation, engaging with community discussions, or experimenting in your own environment.
 ## License and Legal Information
--- a/test/helpers/cloudlyfactory.ts
+++ b/test/helpers/cloudlyfactory.ts
@@ -5,13 +5,13 @@ import * as cloudly from '../../ts/index.js';
 const stopFunctions: Array<() => Promise<void>> = [];
-const tapToolsNodeMod = await import('@push.rocks/tapbundle/node');
+const tapToolsNodeMod = await import('@git.zone/tstest/tapbundle_node');
 const smartmongo = await tapToolsNodeMod.tapNodeTools.createSmartmongo();
 stopFunctions.push(async () => {
  await smartmongo.stopAndDumpToDir('./.nogit/mongodump');
 });
 const smarts3 = await tapToolsNodeMod.tapNodeTools.createSmarts3();
-await smarts3.createBucket('cloudly-test');
+await smarts3.createBucket('cloudly_test_bucket');
 stopFunctions.push(async () => {
  await smarts3.stop();
 });
@@ -23,7 +23,9 @@ export const testCloudlyConfig: cloudly.ICloudlyConfig = {
  publicUrl: '127.0.0.1',
  publicPort: '8080',
  mongoDescriptor: await smartmongo.getMongoDescriptor(),
-  s3Descriptor: await smarts3.getS3Descriptor(),
+  s3Descriptor: await smarts3.getS3Descriptor({
    bucketName: 'cloudly_test_bucket'
  }),
  sslMode: 'none',
  ...(() => {
    if (process.env.NPMCI_SECRET01) {
--- a/test/test.apiclient.ts
+++ b/test/test.apiclient.ts
@@ -1,4 +1,4 @@
-import { tap, expect } from '@push.rocks/tapbundle';
+import { tap, expect } from '@git.zone/tstest/tapbundle';
 import * as helpers from './helpers/index.js';
 import * as cloudly from '../ts/index.js';
@@ -14,8 +14,10 @@ tap.preTask('should start cloudly', async () => {
 });
 tap.preTask('should create a new machine user for testing', async () => {
  console.log('🔵 PreTask: Creating first machine user...');
  const machineUser = new testCloudly.authManager.CUser();
  machineUser.id = await testCloudly.authManager.CUser.getNewId();
  console.log(`  - User ID: ${machineUser.id}`);
  machineUser.data = {
    type: 'machine',
    username: 'test',
@@ -27,48 +29,103 @@ tap.preTask('should create a new machine user for testing', async () => {
    }],
    role: 'admin',
  };
  console.log(`  - Username: ${machineUser.data.username}`);
  console.log(`  - Role: ${machineUser.data.role}`);
  console.log(`  - Token: 'test'`);
  console.log(`  - Token roles: ${machineUser.data.tokens[0].assignedRoles}`);
  await machineUser.save();
  console.log('✅ PreTask: First machine user saved successfully');
 });
 tap.test('should create a new cloudlyApiClient', async () => {
  console.log('🔵 Test: Creating CloudlyApiClient...');
  testClient = new cloudlyApiClient.CloudlyApiClient({
    registerAs: 'api',
    cloudlyUrl: `http://${helpers.testCloudlyConfig.publicUrl}:${helpers.testCloudlyConfig.publicPort}`,
  });
  console.log(`  - URL: http://${helpers.testCloudlyConfig.publicUrl}:${helpers.testCloudlyConfig.publicPort}`);
  await testClient.start();
  console.log('✅ CloudlyApiClient started successfully');
  expect(testClient).toBeTruthy();
 });
-tap.test('create a new machine user', async () => {
+tap.test('DEBUG: Check existing users', async () => {
-  const machineUser = await testCloudly.authManager.CUser.createMachineUser('test', 'api');
+  console.log('🔍 DEBUG: Checking existing users in database...');
-  machineUser.data.tokens.push({
+  const allUsers = await testCloudly.authManager.CUser.getInstances({});
-    token: 'test',
+  console.log(`  - Total users found: ${allUsers.length}`);
-    expiresAt: Date.now() + 3600 * 1000 * 24 * 365,
+  for (const user of allUsers) {
-    assignedRoles: ['api'],
+    console.log(`  - User: ${user.data.username} (ID: ${user.id})`);
-  })
+    console.log(`    - Type: ${user.data.type}`);
-  await machineUser.save();
+    console.log(`    - Role: ${user.data.role}`);
-})
+    console.log(`    - Tokens: ${user.data.tokens.length}`);
    for (const token of user.data.tokens) {
      console.log(`      - Token: '${token.token}' | Roles: ${token.assignedRoles?.join(', ')}`);
    }
  }
 });
 tap.test('should get an identity', async () => {
  console.log('🔵 Test: Getting identity by token...');
  console.log(`  - Using token: 'test'`);
  console.log(`  - API URL: http://${helpers.testCloudlyConfig.publicUrl}:${helpers.testCloudlyConfig.publicPort}`);
  try {
    const identity = await testClient.getIdentityByToken('test');
    console.log('✅ Identity retrieved successfully:');
    console.log(`  - Identity exists: ${!!identity}`);
    if (identity) {
      console.log(`  - Identity data:`, JSON.stringify(identity, null, 2));
    }
    expect(identity).toBeTruthy();
-  console.log(identity);
+  } catch (error) {
    console.error('❌ Failed to get identity:');
    console.error(`  - Error message: ${error.message}`);
    console.error(`  - Error stack:`, error.stack);
    throw error;
  }
 });
 let image: Image;
 tap.test('should create and upload an image', async () => {
  console.log('🔵 Test: Creating and uploading image...');
  console.log(`  - Image name: 'test'`);
  console.log(`  - Image description: 'test'`);
  try {
    image = await testClient.image.createImage({
      name: 'test',
      description: 'test'
    });
-  console.log('created image: ', image);
+    console.log('✅ Image created successfully:');
    console.log(`  - Image ID: ${image?.id}`);
    console.log(`  - Image data:`, image);
    expect(image).toBeInstanceOf(Image);
  } catch (error) {
    console.error('❌ Failed to create image:');
    console.error(`  - Error message: ${error.message}`);
    console.error(`  - Error stack:`, error.stack);
    throw error;
  }
 })
 tap.test('should upload an image version', async () => {
  console.log('🔵 Test: Uploading image version...');
  console.log(`  - Version: 'v1.0.0'`);
  console.log(`  - Image exists: ${!!image}`);
  console.log(`  - Image ID: ${image?.id}`);
  try {
    const imageStream = await helpers.getAlpineImageReadableStream();
    console.log('  - Image stream obtained successfully');
    await image.pushImageVersion('v1.0.0', imageStream);
    console.log('✅ Image version uploaded successfully');
  } catch (error) {
    console.error('❌ Failed to upload image version:');
    console.error(`  - Error message: ${error.message}`);
    console.error(`  - Error stack:`, error.stack);
    throw error;
  }
 });
 tap.test('should stop the apiclient', async (toolsArg) => {
--- a/test/test.ts
+++ b/test/test.ts
@@ -1,4 +1,4 @@
-import { expect, tap } from '@push.rocks/tapbundle';
+import { expect, tap } from '@git.zone/tstest/tapbundle';
 import * as helpers from './helpers/index.js';
 import * as cloudly from '../ts/index.js';
--- a/ts/00_commitinfo_data.ts
+++ b/ts/00_commitinfo_data.ts
@@ -3,6 +3,6 @@
 */
 export const commitinfo = {
  name: '@serve.zone/cloudly',
-  version: '4.12.2',
+  version: '5.0.5',
  description: 'A comprehensive tool for managing containerized applications across multiple cloud providers using Docker Swarmkit, featuring web, CLI, and API interfaces.'
 }
--- a/ts/classes.config.ts
+++ b/ts/classes.config.ts
@@ -29,16 +29,17 @@ export class CloudlyConfig {
            publicPort: 'SERVEZONE_PORT',
            mongoDescriptor: {
              mongoDbUrl: 'MONGODB_URL',
-              mongoDbName: 'MONGODB_DATABASE',
+              mongoDbName: 'MONGODB_NAME',
              mongoDbUser: 'MONGODB_USER',
-              mongoDbPass: 'MONGODB_PASSWORD',
+              mongoDbPass: 'MONGODB_PASS',
            },
            s3Descriptor: {
              endpoint: 'S3_ENDPOINT',
              accessKey: 'S3_ACCESSKEY',
              accessSecret: 'S3_SECRETKEY',
              port: 'S3_PORT', // Note: This will remain as a string. Ensure to parse it to an integer where it's used.
-              useSsl: true,
+              useSsl: 'boolean:S3_USESSL' as any as boolean,
              bucketName: 'S3_BUCKET'
            },
            sslMode:
              'SERVEZONE_SSLMODE' as plugins.servezoneInterfaces.data.ICloudlyConfig['sslMode'],
--- a/ts/manager.coreflow/coreflowmanager.ts
+++ b/ts/manager.coreflow/coreflowmanager.ts
@@ -16,24 +16,23 @@ export class CloudlyCoreflowManager {
    this.typedRouter.addTypedHandler<plugins.servezoneInterfaces.requests.identity.IRequest_Any_Cloudly_CoreflowManager_GetIdentityByToken>(
      new plugins.typedrequest.TypedHandler('getIdentityByToken', async (requestData) => {
        // Use getInstance with $elemMatch for querying nested arrays
        const user = await this.cloudlyRef.authManager.CUser.getInstance({
          data: {
-            tokens: [
+            tokens: {
-              {
+              $elemMatch: { token: requestData.token },
-                token: requestData.token,
+            },
          },
            ], // find the proper user here.
          } as any,
        });
        if (!user) {
          throw new plugins.typedrequest.TypedResponseError(
-            'The supplied token is not valid. No matching user found.',
+            'The supplied token is not valid. No matching user found.'
          );
        }
        if (user.data.type !== 'machine') {
          throw new plugins.typedrequest.TypedResponseError(
-            'The supplied token is not valid. The user is not a machine.',
+            'The supplied token is not valid. The user is not a machine.'
          );
        }
        let cluster: Cluster;
@@ -61,7 +60,7 @@ export class CloudlyCoreflowManager {
            }),
          },
        };
-      }),
+      })
    );
    // lets enable the getting of cluster configs
@@ -76,10 +75,10 @@ export class CloudlyCoreflowManager {
          console.log('got cluster config and sending it back to coreflow');
          return {
            configData: await cluster.createSavableObject(),
-            deploymentDirectives: [],
+            services: [],
          };
-        },
+        }
-      ),
+      )
    );
    // lets enable getting of certificates
@@ -89,14 +88,14 @@ export class CloudlyCoreflowManager {
        async (dataArg) => {
          console.log(`incoming API request for certificate ${dataArg.domainName}`);
          const cert = await this.cloudlyRef.letsencryptConnector.getCertificateForDomain(
-            dataArg.domainName,
+            dataArg.domainName
          );
          console.log(`got certificate ready for reponse ${dataArg.domainName}`);
          return {
            certificate: await cert.createSavableObject(),
          };
-        },
+        }
-      ),
+      )
    );
  }
 }
--- a/ts/manager.image/classes.imagemanager.ts
+++ b/ts/manager.image/classes.imagemanager.ts
@@ -156,7 +156,7 @@ export class ImageManager {
    this.smartbucketInstance = new plugins.smartbucket.SmartBucket(
      this.cloudlyRef.config.data.s3Descriptor,
    );
-    const bucket = await this.smartbucketInstance.getBucketByName('cloudly-test');
+    const bucket = await this.smartbucketInstance.getBucketByName(s3Descriptor.bucketName);
    await bucket.fastPut({ path: 'images/00init', contents: 'init' });
    this.imageDir = await bucket.getDirectoryFromPath({
--- a/ts/manager.service/classes.servicemanager.ts
+++ b/ts/manager.service/classes.servicemanager.ts
@@ -62,5 +62,39 @@ export class ServiceManager {
        }
      )
    );
    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.service.IRequest_Any_Cloudly_UpdateService>(
        'updateService',
        async (dataArg) => {
          const service = await Service.getInstance({
            id: dataArg.serviceId,
          });
          service.data = {
            ...service.data,
            ...dataArg.serviceData,
          };
          await service.save();
          return {
            service: await service.createSavableObject(),
          };
        }
      )
    );
    this.typedrouter.addTypedHandler(
      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.service.IRequest_Any_Cloudly_DeleteServiceById>(
        'deleteServiceById',
        async (dataArg) => {
          const service = await Service.getInstance({
            id: dataArg.serviceId,
          });
          await service.delete();
          return {
            success: true,
          };
        }
      )
    );
  }
 }
--- a/ts_apiclient/classes.service.ts
+++ b/ts_apiclient/classes.service.ts
@@ -40,19 +40,7 @@ export class Service implements plugins.servezoneInterfaces.data.IService {
    );
    const response = await createServiceTR.fire({
      identity: cloudlyClientRef.identity,
-      name: serviceDataArg.name,
+      serviceData: serviceDataArg as plugins.servezoneInterfaces.data.IService['data'],
      description: serviceDataArg.description,
      imageId: serviceDataArg.imageId,
      imageVersion: serviceDataArg.imageVersion,
      environment: {},
      secretBundleId: null,
      scaleFactor: 1,
      balancingStrategy: serviceDataArg.balancingStrategy,
      ports: {
        web: null,
      },
      resources: serviceDataArg.resources,
      domains: [],
    });
    const newService = new Service(cloudlyClientRef);
    Object.assign(newService, response.service);
--- a/ts_apiclient/readme.md
+++ b/ts_apiclient/readme.md
@@ -1,187 +1,291 @@
-# @serve.zone/api
+# @serve.zone/api 🔌
-The `@serve.zone/api` module is a robust and versatile API client, designed to facilitate seamless communication with various cloud resources managed by the Cloudly platform. This API client extends a rich set of functionalities, offering developers a comprehensive and programmable interface for interacting with their multi-cloud infrastructure.
+**The powerful API client for Cloudly.** Connect your applications to multi-cloud infrastructure with type-safe, real-time communication.
-## Install
+## 🎯 What is @serve.zone/api?
-To install the `@serve.zone/api` package, execute the following command in your terminal:
+This is your programmatic gateway to the Cloudly platform. Built with TypeScript, it provides a robust, type-safe interface for managing cloud resources, orchestrating containers, and automating infrastructure operations.
 ## ✨ Features
 - **🔒 Type-Safe** - Full TypeScript support with comprehensive interfaces
 - **⚡ Real-Time** - WebSocket-based communication for instant updates
 - **🔑 Secure Authentication** - Token-based identity management
 - **📦 Resource Management** - Complete control over clusters, images, and services
 - **🎭 Multi-Identity** - Support for service accounts and user authentication
 - **🔄 Reactive Streams** - RxJS integration for event-driven programming
 ## 🚀 Installation
 ```bash
-npm install @serve.zone/api --save
+pnpm add @serve.zone/api
 ```
-This command will download the module and add it to your project's `package.json` dependencies, allowing you to utilize its capabilities within your application.
+## 🎬 Quick Start
 ## Usage
 The `@serve.zone/api` client is tailored to handle various operations within a multi-cloud environment efficiently. Throughout this section, we will explore the different features and use-cases of this API client, aiding you in leveraging its full potential.
 ### Prerequisites
 Before integrating `@serve.zone/api` into your project, ensure the following prerequisites are satisfied:
 - You have Node.js installed on your system (preferably the latest Long-Term Support version).
 - You're utilizing a TypeScript-compatible environment for development.
 ### Establishing an API Client Instance
 The cornerstone of using `@serve.zone/api` is initializing a `CloudlyApiClient` instance. It serves as the main point of interaction, enabling communication with underlying cloud infrastructures managed by Cloudly. Here's a basic setup guide:
 ```typescript
 import { CloudlyApiClient, TClientType } from '@serve.zone/api';
 async function initializeClient() {
  const client = new CloudlyApiClient({
    registerAs: 'api' as TClientType,
    cloudlyUrl: 'https://yourcloudly.url:443'
  });
  await client.start();
  return client;
 }
 const cloudlyClient = await initializeClient();
 ```
 The above code initializes the `CloudlyApiClient` object, connecting your application to the configured Cloudly environment.
 ### Authentication and Identity Management
 To execute operations via the API client, authenticated access is necessary. The most prevalent method for this is obtaining an identity token using a service token:
 ```typescript
 import { CloudlyApiClient } from '@serve.zone/api';
-async function authenticate(client: CloudlyApiClient, serviceToken: string) {
+// Initialize the client
-  const identity = await client.getIdentityByToken(serviceToken, {
+const client = new CloudlyApiClient({
  registerAs: 'api',
  cloudlyUrl: 'https://cloudly.example.com:443'
 });
 // Start the connection
 await client.start();
 // Authenticate with a service token
 const identity = await client.getIdentityByToken('your-service-token', {
  tagConnection: true,
  statefullIdentity: true
 });
 console.log('🎉 Connected as:', identity.name);
 ```
 ## 🔐 Authentication
 ### Service Token Authentication
 ```typescript
 // Authenticate using a service token
 const identity = await client.getIdentityByToken(serviceToken, {
  tagConnection: true,        // Tag this connection with the identity
  statefullIdentity: true     // Maintain state across reconnections
 });
 ```
 ### Identity Management
 ```typescript
 // Get current identity
 const currentIdentity = client.identity;
 // Check permissions
 if (currentIdentity.permissions.includes('cluster:write')) {
  // Perform cluster operations
 }
 ```
 ## 📚 Core Operations
 ### 🐳 Image Management
 ```typescript
 // Create an image entry
 const image = await client.images.createImage({
  name: 'my-app',
  description: 'Production application image'
 });
 // Push a new version
 const imageStream = fs.createReadStream('app.tar');
 await image.pushImageVersion('2.0.0', imageStream);
 // List all images
 const images = await client.images.listImages();
 ```
 ### 🌐 Cluster Operations
 ```typescript
 // Get cluster configuration
 const clusterConfig = await client.getClusterConfigFromCloudlyByIdentity(identity);
 // Deploy to cluster
 await client.deployToCluster({
  clusterName: 'production',
  serviceName: 'api-service',
  image: 'my-app:2.0.0',
  replicas: 3
 });
 ```
 ### 🔒 Certificate Management
 ```typescript
 // Request SSL certificate
 const certificate = await client.getCertificateForDomain({
  domainName: 'api.example.com',
  type: 'ssl',
  identity: identity
 });
 // Use certificate in your application
 console.log('Certificate:', certificate.cert);
 console.log('Private Key:', certificate.key);
 ```
 ### 🔐 Secret Management
 ```typescript
 // Create secret group
 const secretGroup = await client.secrets.createSecretGroup({
  name: 'api-secrets',
  secrets: [
    { key: 'DATABASE_URL', value: 'postgres://...' },
    { key: 'REDIS_URL', value: 'redis://...' }
  ]
 });
 // Retrieve secrets
 const secrets = await client.secrets.getSecretGroup('api-secrets');
 ```
 ## 🔄 Real-Time Updates
 Subscribe to configuration changes and server actions using RxJS:
 ```typescript
 // Listen for configuration updates
 client.configUpdateSubject.subscribe({
  next: (config) => {
    console.log('📡 Configuration updated:', config);
    // React to configuration changes
  }
 });
 // Handle server action requests
 client.serverActionSubject.subscribe({
  next: (action) => {
    console.log('⚡ Server action:', action.type);
    // Process server-initiated actions
  }
 });
 ```
 ## 🎯 Advanced Usage
 ### Streaming Operations
 ```typescript
 // Stream logs from a service
 const logStream = await client.logs.streamLogs({
  service: 'api-service',
  follow: true
 });
 logStream.on('data', (log) => {
  console.log(log.message);
 });
 ```
 ### Batch Operations
 ```typescript
 // Deploy multiple services
 const deployments = await Promise.all([
  client.deploy({ service: 'frontend', image: 'app:latest' }),
  client.deploy({ service: 'backend', image: 'api:latest' }),
  client.deploy({ service: 'worker', image: 'worker:latest' })
 ]);
 ```
 ### Error Handling
 ```typescript
 try {
  await client.start();
 } catch (error) {
  if (error.code === 'AUTH_FAILED') {
    console.error('Authentication failed:', error.message);
  } else if (error.code === 'CONNECTION_LOST') {
    console.error('Connection lost, retrying...');
    await client.reconnect();
  }
 }
 ```
 ## 🧹 Cleanup
 Always gracefully disconnect when done:
 ```typescript
 // Stop the client connection
 await client.stop();
 console.log('✅ Disconnected cleanly');
 ```
 ## 🔌 API Reference
 ### CloudlyApiClient
 Main client class for interacting with Cloudly.
 #### Constructor Options
 ```typescript
 interface ICloudlyApiClientOptions {
  registerAs: TClientType;  // 'api' | 'cli' | 'web'
  cloudlyUrl: string;        // Full URL including protocol and port
 }
 ```
 #### Methods
 - `start()` - Initialize connection
 - `stop()` - Close connection
 - `getIdentityByToken()` - Authenticate with token
 - `getClusterConfigFromCloudlyByIdentity()` - Get cluster configuration
 - `getCertificateForDomain()` - Request SSL certificate
 - `images` - Image management namespace
 - `secrets` - Secret management namespace
 - `clusters` - Cluster management namespace
 ## 🎬 Complete Example
 ```typescript
 import { CloudlyApiClient } from '@serve.zone/api';
 async function main() {
  // Initialize client
  const client = new CloudlyApiClient({
    registerAs: 'api',
    cloudlyUrl: 'https://cloudly.example.com:443'
  });
  try {
    // Connect and authenticate
    await client.start();
    const identity = await client.getIdentityByToken(process.env.SERVICE_TOKEN, {
      tagConnection: true,
      statefullIdentity: true
    });
-  console.log(`Authenticated identity:`, identity);
+    // Create and deploy an image
-  return identity;
+    const image = await client.images.createImage({
-}
+      name: 'my-service',
-
+      description: 'Microservice application'
 const serviceToken = 'your_service_token';
 const identity = await authenticate(cloudlyClient, serviceToken);
 ```
 In this function, the `getIdentityByToken` method authenticates using a service token and acquires an identity object that includes user details and security claims.
 ### Interacting with Cloudly Features
 #### Image Management
 Image management is one of the key features supported by the API Client. You can create, upload, and manage Docker images easily within your cloud ecosystem:
 ```typescript
 async function manageImages(client: CloudlyApiClient, identity) {
  // Creating a new image
  const newImage = await client.images.createImage({
    name: 'my_new_image',
    description: 'A test image'
    });
-  console.log(`Created image:`, newImage);
+    // Push image version
    const stream = getImageStream(); // Your image stream
    await image.pushImageVersion('1.0.0', stream);
-  // Uploading an image version
+    // Deploy to cluster
-  const imageStream = fetchYourImageStreamHere(); // Provide the source image stream
+    await client.deployToCluster({
-  await newImage.pushImageVersion('1.0.0', imageStream);
+      clusterName: 'production',
-  console.log('Image version uploaded successfully.');
+      serviceName: 'my-service',
-}
+      image: 'my-service:1.0.0',
-
+      replicas: 3,
-await manageImages(cloudlyClient, identity);
+      environment: {
-
+        NODE_ENV: 'production'
 // Helper function for obtaining image stream (implement accordingly)
 function fetchYourImageStreamHere() {
  // Logic to fetch and return a readable stream for your image
  return new ReadableStream<Uint8Array>();
 }
 ```
 In this example, the `manageImages` function underscores the typical workflow of creating an image entry within Cloudly and then proceeding to upload a specific version using the `pushImageVersion` method.
 #### Cluster Configuration
 Another powerful capability is managing clusters, which allows for orchestrating and configuring Docker Swarm clusters:
 ```typescript
 async function configureCluster(client: CloudlyApiClient, identity) {
  // Fetching cluster configuration
  const clusterConfig = await client.getClusterConfigFromCloudlyByIdentity(identity);
  console.log(`Cluster configuration retrieved:`, clusterConfig);
 }
 await configureCluster(cloudlyClient, identity);
 ```
 The `getClusterConfigFromCloudlyByIdentity` method retrieved the configuration needed to set up and manage your clusters within the multi-cloud environment.
 ### Advanced Communication via Typed Sockets
 The API client leverages `TypedRequest` and `TypedSocket` from the `@api.global` family, enabling statically-typed, real-time communication. Here's an example demonstrating socket integration:
 ```typescript
 async function configureSocketCommunication(client: CloudlyApiClient) {
  client.configUpdateSubject.subscribe({
    next: (configData) => {
      console.log('Received configuration update:', configData);
      }
    });
-  client.serverActionSubject.subscribe({
+    console.log('✅ Deployment successful!');
    next: (actionRequest) => {
      console.log('Server action requested:', actionRequest);
    }
  });
 }
-configureSocketCommunication(cloudlyClient);
+  } catch (error) {
-```
+    console.error('❌ Error:', error);
-
+  } finally {
 The client utilizes RxJS `Subject` to enable simple yet powerful handling of incoming socket requests, whereby one can act upon updates and actions as they occur.
 ### Integrating Certificates
 Certificate operations, such as obtaining SSL certificates for your domains, are also streamlined using this API client:
 ```typescript
 async function retrieveCertificate(client: CloudlyApiClient, domainName: string, identity) {
  const certificate = await client.getCertificateForDomain({
    domainName: domainName,
    type: 'ssl',
    identity: identity
  });
  console.log('Retrieved SSL Certificate:', certificate);
 }
 const yourDomain = 'example.com';
 await retrieveCertificate(cloudlyClient, yourDomain, identity);
 ```
 This example demonstrates fetching SSL certificates using given domain credentials and an authenticated identity.
 ### API Client Cleanup
 When operations are complete and the application is shutting down, it's crucial to gracefully terminate the API client connection:
 ```typescript
 async function cleanup(client: CloudlyApiClient) {
    await client.stop();
-  console.log('Cloudly API client disconnected gracefully.');
+  }
 }
-await cleanup(cloudlyClient);
+main();
 ```
 By invoking the `stop` method, the API client securely terminates its connection to ensure no resources are left hanging, preventing potential memory leaks.
 ### Miscellaneous Features
 This section would be remiss without mentioning various utility functionalities such as secret management, server actions, DNS configurator options, and more, all underpinned by an intelligently designed API, enriching cloud resource interactivity.
 In conclusion, by employing `@serve.zone/api`, developers gain unparalleled access to a multitude of modular functions pertinent to multi-cloud administration, significantly amplifying productivity and management effectiveness across diverse computing environments.
 ## License and Legal Information
 This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. 
--- a/ts_cliclient/readme.md
+++ b/ts_cliclient/readme.md
@@ -1,246 +1,342 @@
-# @serve.zone/cli
+# @serve.zone/cli 🚀
-A comprehensive command-line interface (CLI) tool for managing multi-cloud environments, leveraging the features of the @serve.zone/cloudly platform. This CLI is crafted to facilitate seamless interactions with complex cloud configurations and deployments, utilizing Docker Swarmkit orchestration.
+**Command-line interface for Cloudly.** Manage your multi-cloud infrastructure from the terminal with powerful, intuitive commands.
-## Install
+## 🎯 What is @serve.zone/cli?
-To begin using the `@serve.zone/cli` in your projects, install it via npm by running:
+The Cloudly CLI brings the full power of the Cloudly platform to your terminal. Whether you're automating deployments, managing secrets, or monitoring services, the CLI provides a streamlined interface for all your cloud operations.
 ## ✨ Features
 - **⚡ Fast & Efficient** - Optimized for speed and minimal resource usage
 - **🔐 Secure Authentication** - Token-based authentication with secure storage
 - **📝 Intuitive Commands** - Clear, consistent command structure
 - **🎨 Formatted Output** - Beautiful, readable output with color coding
 - **🔄 Scriptable** - Perfect for CI/CD pipelines and automation
 - **📊 Comprehensive** - Access to all Cloudly features from the terminal
 ## 🚀 Installation
 ### Global Installation (Recommended)
 ```bash
-npm install @serve.zone/cli --save
+pnpm add -g @serve.zone/cli
 ```
-This command will download the package and integrate it into your project's `node_modules` directory, reflecting the dependency in your `package.json`.
+### Local Installation
-## Usage
+```bash
-
+pnpm add @serve.zone/cli
 The `@serve.zone/cli` is a powerful command-line tool aimed at developers and system administrators who are managing containerized applications across various cloud platforms. Through this CLI, users can interact with their cloud infrastructure efficiently, enabling and extending `Cloudly’s` capabilities directly from the terminal.
 ### Prerequisites
 Before proceeding to use the `@serve.zone/cli`, ensure your system meets the following prerequisites:
 - Latest Node.js LTS version installed.
 - Familiarity with basic command-line operations.
 - Properly configured cloud service accounts (like Cloudflare, Hetzner), necessary for managing respective services.
 ### Setting Up the CLI
 Begin setting up the `Cloudly` instance for CLI usage:
 ```typescript
 // Import required modules
 import { Cloudly } from '@serve.zone/cloudly';
 import * as path from 'path';
 // Define the configuration needed for cloud operations
 const cloudlyConfig = {
  cfToken: 'your-cloudflare-token',
  hetznerToken: 'your-hetzner-token',
  environment: 'production',
  publicUrl: 'your-public-url',
 };
 // Instantiate and start the Cloudly instance
 const cloudlyInstance = new Cloudly(cloudlyConfig);
 await cloudlyInstance.start();
 // Log the setup information to ensure it’s correct
 console.log(`Cloudly is set up at ${cloudlyInstance.config.data.publicUrl}`);
 ```
-This snippet initializes a Cloudly instance with necessary environment configuration, setting the groundwork for all subsequent CLI operations.
+## 🎬 Quick Start
-### Core Operations with the CLI
+```bash
 # Configure your Cloudly instance
 servezone config --url https://cloudly.example.com
-Here's how you leverage various operational commands within the CLI feature:
+# Login with your service token
 servezone login --token your-service-token
-#### Managing Clusters
+# List your clusters
 servezone clusters list
-To create, list, and delete clusters, you’ll require invoking the `Cloudly` class with its cluster management logic:
+# Deploy a service
-
+servezone deploy --cluster production --image myapp:latest
 ```typescript
 // Module imports
 import { Cloudly } from '@serve.zone/cloudly';
 // Async function for cluster management
 async function manageCluster() {
  // Prepare configuration
  const config = {
    cfToken: 'YOUR_CLOUDFLARE_TOKEN',
    hetznerToken: 'YOUR_HETZNER_TOKEN',
  };
  // Initialize Cloudly
  const cloudlyInstance = new Cloudly(config);
  await cloudlyInstance.start();
  // Example: Creating a new cluster
  const cluster = await cloudlyInstance.clusterManager.createCluster({
    id: 'example_cluster_id',
    data: {
      name: 'example_cluster',
      servers: [],
      sshKeys: [],
    }
  });
  // Log cluster details
  console.log('Cluster created:', cluster);
 }
 ```
 With the above example, you can dynamically manage cluster configurations, ensuring your application components are effectively orchestrated across cloud environments.
 #### Deploying Services
 Deploying cloud-native services within your clusters can be achieved through the CLI:
 ```typescript
 import { Cloudly } from '@serve.zone/cloudly';
 // Function to handle service deployment
 async function deployService() {
  const config = {
    cfToken: 'YOUR_CLOUDFLARE_TOKEN',
    hetznerToken: 'YOUR_HETZNER_TOKEN',
  };
  const cloudlyInstance = new Cloudly(config);
  await cloudlyInstance.start();
  // Deploy a new service to a specified cluster
  const newService = {
    id: 'example_service_id',
    data: {
      name: 'example_service',
      imageId: 'example_image_id',
      imageVersion: '1.0.0',
      environment: {},
      ports: { web: 80 }
    }
  };
  // Store service into database and deploy
  console.log('Deploying service:', newService)
  await cloudlyInstance.serverManager.deployService(newService);
 }
 deployService();
 ```
-By streamlining your service deployments through CLI, you ensure reproducibility and clarity in development operations.
+## 🔑 Authentication
-#### Managing Certificates
+### Initial Setup
-Ensuring secure connections by managing SSL certificates is essential. The CLI aids in this through Let's Encrypt integration:
+```bash
 # Set your Cloudly instance URL
 servezone config --url https://cloudly.example.com
-```typescript
+# Authenticate with a service token
-import { Cloudly } from '@serve.zone/cloudly';
+servezone login --token YOUR_SERVICE_TOKEN
-// Function to acquire a certificate
+# Or use environment variables
-async function getCertificate() {
+export CLOUDLY_URL=https://cloudly.example.com
-  const config = {
+export CLOUDLY_TOKEN=YOUR_SERVICE_TOKEN
    cfToken: 'YOUR_CLOUDFLARE_TOKEN',
    hetznerToken: 'YOUR_HETZNER_TOKEN',
  };
  const cloudlyInstance = new Cloudly(config);
  await cloudlyInstance.start();
  // Fetch certificate using Let's Encrypt
  const domainName = 'example.com';
  const cert = await cloudlyInstance.letsencryptConnector.getCertificateForDomain(domainName);
  console.log(`Obtained certificate for domain ${domainName}:`, cert);
 }
 getCertificate();
 ```
-This process facilitates the automation of SSL certificates provisioning, ensuring high security in your apps.
+### Managing Profiles
-### Automating Tasks with the CLI
+```bash
 # Create a profile for different environments
 servezone profile create production --url https://prod.cloudly.com
 servezone profile create staging --url https://stage.cloudly.com
-Task scheduling is a feature you can utilize to automate recurring processes. Here’s an example of how `@serve.zone/cli` accomplishes task scheduling:
+# Switch between profiles
 servezone profile use production
-```typescript
+# List all profiles
-import { TaskBuffer } from '@push.rocks/taskbuffer';
+servezone profile list
 // Schedule a task to run every day
 const dailyTask = new TaskBuffer({
  schedule: '0 0 * * *', // Using cron schedule
  taskFunction: async () => {
    console.log('Performing daily backup check...');
    // Include backup logic here
  },
 });
 // Initiate task scheduling
 dailyTask.start();
 ```
-Scheduled tasks like periodic maintenance, data synchronization, or backups ensure you keep your cloud environment robust and reliable.
+## 📚 Core Commands
-### Integrating Third-Party APIs
+### 🌐 Cluster Management
-Expand the scope of your applications with API integrations offered via `@serve.zone/cli`:
+```bash
 # List all clusters
 servezone clusters list
-```typescript
+# Get cluster details
-import { Cloudly } from '@serve.zone/cloudly';
+servezone clusters info production-cluster
-// Function to send notifications
+# Create a new cluster
-async function sendNotification() {
+servezone clusters create \
-  const cloudlyConfig = {
+  --name production-cluster \
-    cfToken: 'your-cloudflare-token',
+  --region eu-central \
-    hetznerToken: 'your-hetzner-token',
+  --nodes 3
  };
-  const cloudly = new Cloudly(cloudlyConfig);
+# Scale a cluster
-  await cloudly.start();
+servezone clusters scale production-cluster --nodes 5
-  // Configure and send push notification
+# Delete a cluster
-  await cloudly.externalApiManager.sendPushMessage({
+servezone clusters delete staging-cluster
    deviceToken: 'some_device_token',
    message: 'Hello from Cloudly!',
  });
 }
 sendNotification();
 ```
-API integrations via the CLI extend Cloudly’s reach, enabling comprehensive service interconnections.
+### 🐳 Service Deployment
-### Security and Access Management
+```bash
 # Deploy a service
 servezone deploy \
  --cluster production \
  --name api-service \
  --image myapp:2.0.0 \
  --replicas 3 \
  --port 80:3000
-Effective identity management is possible through `@serve.zone/cli`. Manage user roles, token validations, and more:
+# Update a service
 servezone service update api-service \
  --image myapp:2.1.0 \
  --replicas 5
-```typescript
+# Scale a service
-import { Cloudly } from '@serve.zone/cloudly';
+servezone service scale api-service --replicas 10
-// Configuring and verifying identity
+# Remove a service
-async function authenticateUser() {
+servezone service remove api-service
  const cloudlyConfig = {
    cfToken: 'your-cloudflare-token',
    hetznerToken: 'your-hetzner-token',
  };
  const cloudly = new Cloudly(cloudlyConfig);
  await cloudly.start();
  // Sample user credentials
  const userIdentity = {
    userId: 'unique_user_id',
    jwt: 'user_jwt_token',
  };
  // Validate identity
  const isValid = cloudly.authManager.validateIdentity(userIdentity);
  console.log(`Is user identity valid? ${isValid}`);
 }
 authenticateUser();
 ```
-The applications of identity validation streamline operational security and enforce access controls across your systems.
+### 🔐 Secret Management
-These examples offer a glimpse into the vast potential of @serve.zone/cli, which combines automation, security, and flexibility for state-of-the-art cloud management. You are encouraged to build upon this documentation to harness Cloudly's full capabilities in your infrastructure and process ecosystems. Let the CLI transform your cloud management experience with precision and adaptability.
+```bash
 # Create a secret
 servezone secrets create \
  --name database-url \
  --value "postgres://user:pass@host/db"
 # Create a secret group
 servezone secrets create-group \
  --name api-secrets \
  --secret DATABASE_URL=postgres://... \
  --secret REDIS_URL=redis://...
 # List secrets
 servezone secrets list
 # Get secret value
 servezone secrets get database-url
 # Delete a secret
 servezone secrets delete old-secret
 ```
 ### 📦 Image Management
 ```bash
 # List images
 servezone images list
 # Push a new image
 servezone images push \
  --name myapp \
  --version 2.0.0 \
  --file ./myapp.tar
 # Tag an image
 servezone images tag myapp:2.0.0 myapp:latest
 # Delete an image
 servezone images delete myapp:1.0.0
 ```
 ### 📊 Monitoring & Logs
 ```bash
 # View service logs
 servezone logs api-service
 # Follow logs in real-time
 servezone logs api-service --follow
 # Filter logs
 servezone logs api-service --since 1h --grep ERROR
 # Get service status
 servezone service status api-service
 # Monitor cluster health
 servezone clusters health production-cluster
 ```
 ### 🔧 DNS Management
 ```bash
 # List DNS records
 servezone dns list --domain example.com
 # Create a DNS record
 servezone dns create \
  --domain example.com \
  --name api \
  --type A \
  --value 192.168.1.1
 # Update a DNS record
 servezone dns update api.example.com --value 192.168.1.2
 # Delete a DNS record
 servezone dns delete old.example.com
 ```
 ## 🎯 Advanced Usage
 ### Environment Variables
 ```bash
 # Set environment variables for a service
 servezone deploy \
  --name api-service \
  --env NODE_ENV=production \
  --env PORT=3000 \
  --env DATABASE_URL=@secret:database-url
 ```
 ### Configuration Files
 Create a `cloudly.yaml` file:
 ```yaml
 cluster: production
 service:
  name: api-service
  image: myapp:latest
  replicas: 3
  ports:
    - 80:3000
  environment:
    NODE_ENV: production
    DATABASE_URL: "@secret:database-url"
 ```
 Deploy using the config file:
 ```bash
 servezone deploy --config cloudly.yaml
 ```
 ### Batch Operations
 ```bash
 # Deploy multiple services
 servezone deploy --config services/*.yaml
 # Update all services in a namespace
 servezone service update --namespace api --image-tag v2.0.0
 # Delete all staging resources
 servezone cleanup --environment staging
 ```
 ## 🔄 CI/CD Integration
 ### GitHub Actions
 ```yaml
 - name: Deploy to Cloudly
  run: |
    servezone config --url ${{ secrets.CLOUDLY_URL }}
    servezone login --token ${{ secrets.CLOUDLY_TOKEN }}
    servezone deploy \
      --cluster production \
      --name api-service \
      --image myapp:${{ github.sha }}
 ```
 ### GitLab CI
 ```yaml
 deploy:
  script:
    - servezone config --url $CLOUDLY_URL
    - servezone login --token $CLOUDLY_TOKEN
    - servezone deploy --config cloudly.yaml
 ```
 ## 🎨 Output Formats
 ```bash
 # JSON output for scripting
 servezone clusters list --output json
 # YAML output
 servezone service info api-service --output yaml
 # Table output (default)
 servezone images list --output table
 # Quiet mode (IDs only)
 servezone clusters list --quiet
 ```
 ## 🛠️ Troubleshooting
 ```bash
 # Enable debug output
 servezone --debug clusters list
 # Check CLI version
 servezone version
 # Test connection
 servezone ping
 # View configuration
 servezone config show
 # Clear cache and credentials
 servezone logout --clear-cache
 ```
 ## 📝 Command Reference
 ```bash
 servezone --help                    # Show all commands
 servezone <command> --help          # Show command-specific help
 servezone clusters --help           # Show cluster commands
 servezone service --help            # Show service commands
 servezone secrets --help            # Show secret commands
 ```
 ## 🔌 Shell Completion
 Enable tab completion for your shell:
 ```bash
 # Bash
 servezone completion bash > /etc/bash_completion.d/servezone
 # Zsh
 servezone completion zsh > ~/.zsh/completions/_servezone
 # Fish
 servezone completion fish > ~/.config/fish/completions/servezone.fish
 ```
 ## License and Legal Information
--- a/ts_interfaces/platformservice/mta.ts
+++ b/ts_interfaces/platformservice/mta.ts
@@ -2,9 +2,9 @@ import * as plugins from '../plugins.js';
 export type TTemplates = 'default' | 'linkaction' | 'notification';
-export interface IRequest_SendEmail extends plugins.typedrequestInterfaces.implementsTR<
+export interface IReq_SendEmail extends plugins.typedrequestInterfaces.implementsTR<
  plugins.typedrequestInterfaces.ITypedRequest,
-  IRequest_SendEmail
+  IReq_SendEmail
 > {
  method: 'sendEmail';
  request: {
@@ -25,9 +25,9 @@ export interface IRequest_SendEmail extends plugins.typedrequestInterfaces.imple
  };
 }
-export interface IRequestRegisterRecipient extends plugins.typedrequestInterfaces.implementsTR<
+export interface IReq_RegisterRecipient extends plugins.typedrequestInterfaces.implementsTR<
  plugins.typedrequestInterfaces.ITypedRequest,
-  IRequestRegisterRecipient
+  IReq_RegisterRecipient
 > {
  method: 'registerRecepient';
  request: {
@@ -37,3 +37,34 @@ export interface IRequestRegisterRecipient extends plugins.typedrequestInterface
    status: 'ok' | 'not ok';
  };
 }
 export interface IReq_CheckEmailStatus extends plugins.typedrequestInterfaces.implementsTR<
  plugins.typedrequestInterfaces.ITypedRequest,
  IReq_CheckEmailStatus
 > {
  method: 'checkEmailStatus';
  request: {
    emailId: string;
  };
  response: {
    status: string,
    details?: { message: string; }
  };
 }
 export interface IReq_GetEMailStats extends plugins.typedrequestInterfaces.implementsTR<
  plugins.typedrequestInterfaces.ITypedRequest,
  IReq_GetEMailStats
 > {
  method: 'getEmailStats';
  request: {
    jwt: string;
  };
  response: {
    totalEmailsSent: number;
    totalEmailsDelivered: number;
    totalEmailsBounced: number;
    averageDeliveryTimeMs: number;
    lastUpdated: string;
  };
 }
--- a/ts_interfaces/readme.md
+++ b/ts_interfaces/readme.md
@@ -1,207 +1,375 @@
-# @serve.zone/interfaces
+# @serve.zone/interfaces 📋
-interfaces for working with containers
+**TypeScript interfaces for the Cloudly ecosystem.** Type-safe contracts for multi-cloud infrastructure management.
-## Install
+## 🎯 What is @serve.zone/interfaces?
-To install `@serve.zone/interfaces`, run the following command in your terminal:
+This package provides the complete set of TypeScript interfaces that power the Cloudly platform. It ensures type safety and consistency across all components - from API requests to data models, from service definitions to infrastructure configurations.
 ## ✨ Features
 - **🔒 Type Safety** - Comprehensive TypeScript interfaces for all Cloudly operations
 - **📦 Modular Structure** - Organized by domain for easy navigation
 - **🔄 Version Compatibility** - Interfaces versioned with the platform
 - **📚 Well Documented** - Each interface includes JSDoc comments
 - **🎭 Multi-Purpose** - Used by API clients, CLI tools, and web interfaces
 - **✅ Validation Ready** - Compatible with runtime type checking libraries
 ## 🚀 Installation
 ```bash
-npm install @serve.zone/interfaces --save
+pnpm add @serve.zone/interfaces
 ```
-This will add `@serve.zone/interfaces` to your project's dependencies, allowing you to import and use various predefined interfaces that facilitate container operations and interactions within the ServeZone ecosystem.
+## 🏗️ Interface Categories
-## Usage
+### 📡 Request/Response Interfaces
-The `@serve.zone/interfaces` module provides a robust set of TypeScript interfaces designed to standardize interaction with various services and components in a cloud-native environment. The interfaces are targeted at simplifying the integration process with container orchestration, network configurations, logging, and service definitions. The module is particularly useful if you're working on infrastructure or service orchestration solutions using Node.js and TypeScript.
+Typed contracts for API communication:
 This document guides you through a comprehensive use case scenario of `@serve.zone/interfaces`. We will cover how to effectively utilize these interfaces to set up cloud services, manage application configurations, and handle system-related communications. This tutorial will explore various feature sets within the module, focusing on real-world implementations and practical coding strategies.
 ### Prerequisites
 Before diving in, make sure to satisfy the following prerequisites:
 - **Node.js**: Ensure you have Node.js installed (preferably the latest LTS version).
 - **TypeScript**: Your environment should support TypeScript, as this module leverages strong typing offered by TypeScript.
 - **Cloud Account Access**: Some of the interfaces interact with live cloud services; thus, ensure you have necessary credentials (like API tokens) available for testing or integration.
 ### Core Interfaces and Scenarios
 #### 1. Handling Typed Requests
 One fundamental aspect is defining typed requests, which standardizes API call definitions across different microservices or components. The module offers interfaces such as `IRequest_GetAllImages`, `IRequest_CreateCluster`, that you can extend or implement within your service logic to ensure strong typing and consistency.
 ```typescript
-import { IRequest_GetAllImages } from '@serve.zone/interfaces/requests/image';
+import { 
  IRequest_GetAllImages,
  IRequest_CreateCluster,
  IRequest_DeployService 
 } from '@serve.zone/interfaces';
-class ImageService {
+// Type-safe request
-  private cloudlyClient;
+const request: IRequest_GetAllImages['request'] = {
-
+  identity: userIdentity,
-  constructor(cloudlyClient: CloudlyApiClient) {
+  filters: {
-    this.cloudlyClient = cloudlyClient;
+    tag: 'production'
  }
 };
-  public async fetchAllImages() {
+// Type-safe response
-    const request: IRequest_GetAllImages['request'] = {
+const response: IRequest_GetAllImages['response'] = {
-      identity: this.cloudlyClient.identity,
+  images: [...]
-    };
+};
    const response = await this.cloudlyClient.typedsocketClient.fireTypedRequest<IRequest_GetAllImages>(request);
    return response.images;
  }
 }
 ```
-In the above code, we structured a simple function to retrieve all images from a service, assuming the `cloudlyClient` is your authenticated API client. The typed request interface ensures that both the request and response align with the expected types.
+### 📦 Data Models
-#### 2. Logging and Smart Logging Interfaces
+Core data structures for Cloudly entities:
 Logging is a crucial aspect of cloud applications. The module provides interfaces to assist in integrating logging systems like `@push.rocks/smartlog-interfaces`.
 ```typescript
-import { ILogger, ILogConfig } from '@push.rocks/smartlog-interfaces';
+import { 
  ICluster, 
  IService, 
  IImage, 
  ISecret,
  IServer 
 } from '@serve.zone/interfaces';
-class LoggerService {
+// Define a service
-  private logger: ILogger;
+const service: IService = {
-
+  id: 'service-123',
  constructor(logConfig: ILogConfig) {
    this.logger = new SmartLogger(logConfig);
  }
  public logMessage(logPackage: ILogPackage) {
    this.logger.log(logPackage);
  }
 }
 ```
 This illustrates a logger service utilizing `ILogConfig` to configure and initiate a logging mechanism. You can log structured data using `logPackage`, thus enhancing traceability and debugging efficiency.
 #### 3. Container Service Management
 Managing containers, particularly when dealing with microservices, can be complex, but interfaces like `IService`, `ICluster`, and `IServer` aid in structuring container service management.
 ```typescript
 import { IService } from '@serve.zone/interfaces/data/service';
 function defineService(): IService {
  return {
    id: 'unique-service-id',
  data: {
-      name: 'my-container-service',
+    name: 'api-service',
-      imageId: 'unique-image-id',
+    imageId: 'image-456',
-      imageVersion: '1.0.0',
+    imageVersion: '2.0.0',
-      environment: { KEY: 'VALUE' },
+    environment: {
-      secretBundleId: 'bundle-id',
+      NODE_ENV: 'production'
-      scaleFactor: 2,
+    },
    scaleFactor: 3,
    balancingStrategy: 'round-robin',
-      ports: { web: 80 },
+    ports: {
-      domains: [{ name: 'example.com' }],
+      web: 80,
      metrics: 9090
    },
    domains: [
      { name: 'api.example.com' }
    ],
    deploymentIds: [],
-      deploymentDirectiveIds: [],
+    deploymentDirectiveIds: []
  }
-  };
+};
 }
 ```
-In the example, a service definition is drafted, encapsulating critical service metadata, including its environment variables, domain configuration, and load balancing strategy. Adhering to `IService` ensures that all necessary service data is encapsulated correctly.
+### 🔐 Authentication & Identity
-#### 4. Network Configuration and Routing
+Identity management interfaces:
 Networking is integral to cloud-native applications. Interfaces in `@serve.zone/interfaces` help shape network interaction patterns.
 ```typescript
-import { IReverseProxyConfig } from '@serve.zone/interfaces/data/traffic';
+import { 
  IIdentity, 
  IServiceToken,
  IPermission 
 } from '@serve.zone/interfaces';
 const identity: IIdentity = {
  id: 'user-789',
  name: 'service-account',
  type: 'service',
  permissions: ['cluster:read', 'service:write'],
  tokenHash: 'hashed-token',
  metadata: {
    createdAt: new Date(),
    lastAccess: new Date()
  }
 };
 ```
 ### 🌐 Network Configuration
 Networking and routing interfaces:
 ```typescript
 import { 
  IReverseProxyConfig,
  IDomainConfig,
  ILoadBalancerConfig 
 } from '@serve.zone/interfaces';
 const proxyConfig: IReverseProxyConfig = {
-  domain: 'example.com',
+  domain: 'app.example.com',
-  path: '/',
+  path: '/api',
-  serviceAddress: 'http://service:8080',
+  serviceAddress: 'http://api-service:3000',
  ssl: true,
  headers: {
    'X-Real-IP': '$remote_addr'
  }
 };
 function configureProxy() {
  // Logic to apply the proxyConfig, potentially using Typedi, Smartclient, or similar libraries.
 }
 ```
-Here, `IReverseProxyConfig` is used to define a reverse proxy for a service. Such configurations are necessary for routing external requests into internal services securely.
+### 📊 Monitoring & Metrics
-### Advanced Interface Utilization
+Observability interfaces:
 #### Monitoring and Metrics Collection
 For observability, you can track system metrics using `IServerMetrics` or cluster status interfaces.
 ```typescript
-import { IServerMetrics } from '@serve.zone/interfaces/data/server';
+import { 
  IServerMetrics,
  IServiceMetrics,
  IClusterHealth 
 } from '@serve.zone/interfaces';
-function reportMetrics(metrics: IServerMetrics) {
+const metrics: IServerMetrics = {
-  console.log(`CPU Usage: ${metrics.cpuUsageInPercent}%`);
+  serverId: 'server-001',
-  console.log(`Memory Usage: ${metrics.memoryUsageinMB}MB`);
+  cpuUsageInPercent: 65,
-}
+  memoryUsageinMB: 3072,
-
+  memoryAvailableInMB: 8192,
-const sampleMetrics: IServerMetrics = {
+  diskUsageInPercent: 40,
-  serverId: 'server-123',
+  networkInMbps: 100,
-  cpuUsageInPercent: 45,
+  networkOutMbps: 150,
-  memoryUsageinMB: 2048,
+  containerCount: 12,
-  memoryAvailableInMB: 4096,
+  containerMetrics: [...]
  containerCount: 10,
  containerMetrics: [],
 };
 reportMetrics(sampleMetrics);
 ```
-Implementing such metrics tracking provides insight into performance bottlenecks and helps strategize scaling decisions.
+### 🔒 Secret Management
-#### Certificate Management
+Security and credential interfaces:
 To handle SSL certificates programmatically, utilize interfaces such as `IRequest_Any_Cloudly_GetCertificateForDomain`.
 ```typescript
-import { IRequest_Any_Cloudly_GetCertificateForDomain } from '@serve.zone/interfaces/requests/certificate';
+import { 
  ISecretGroup,
  ISecretBundle,
  IEncryptedData 
 } from '@serve.zone/interfaces';
-async function fetchCertificate(cloudlyClient: CloudlyApiClient, domainName: string) {
+const secretGroup: ISecretGroup = {
-  const request: IRequest_Any_Cloudly_GetCertificateForDomain['request'] = {
+  id: 'secrets-123',
-    identity: cloudlyClient.identity,
+  name: 'database-credentials',
-    domainName: domainName,
+  secrets: [
-    type: 'ssl'
+    {
      key: 'DB_HOST',
      value: 'encrypted-value',
      encrypted: true
    },
    {
      key: 'DB_PASSWORD',
      value: 'encrypted-value',
      encrypted: true
    }
  ],
  metadata: {
    environment: 'production',
    service: 'api'
  }
 };
 ```
 ## 📚 Common Usage Patterns
 ### Creating Type-Safe API Clients
 ```typescript
 import { 
  IRequest_CreateService,
  IService 
 } from '@serve.zone/interfaces';
 class ServiceClient {
  async createService(
    serviceData: IService['data']
  ): Promise<IService> {
    const request: IRequest_CreateService['request'] = {
      identity: this.identity,
      serviceData
    };
-  return await cloudlyClient.typedsocketClient.fireTypedRequest<IRequest_Any_Cloudly_GetCertificateForDomain>(request);
+    const response = await this.client.send<IRequest_CreateService>(
      'createService',
      request
    );
    return response.service;
  }
 }
 ```
-Managing certificates dynamically via typed requests simplifies deployment and automates the security dimensions of your applications.
+### Validating Incoming Data
 #### Integrating with External Messaging Services
 Use `IRequest_SendEmail` to integrate platform services for sending emails:
 ```typescript
-import { IRequest_SendEmail } from '@serve.zone/interfaces/platformservice/mta';
+import { ICluster } from '@serve.zone/interfaces';
 import { validateType } from 'your-validation-library';
-async function sendNotification(emailClient: any) {
+function validateClusterData(data: unknown): ICluster {
-  const emailRequest: IRequest_SendEmail['request'] = {
+  if (!validateType<ICluster>(data)) {
-    title: 'Welcome to ServeZone!',
+    throw new Error('Invalid cluster data');
-    from: 'service@company.com',
+  }
-    to: 'user@example.com',
+  return data;
    body: '<h1>Congratulations</h1><p>Your account has been created successfully.</p>',
  };
  await emailClient.sendEmail(emailRequest);
 }
 ```
-This approach demonstrates abstracting the email sending functionality using typed interfaces, contributing to code consistency and robustness.
+### Building Configuration Objects
-### Conclusion
+```typescript
 import { 
  ICloudlyConfig,
  IMongoDescriptor 
 } from '@serve.zone/interfaces';
-The `@serve.zone/interfaces` module equips developers with a set of interfaces tailored for managing containers, orchestrating cloud services, and handling system interactions seamlessly. By applying these interfaces, projects can achieve coherence, reduce coupling, and simplify the integration process across various service domains.
+const config: ICloudlyConfig = {
  cfToken: process.env.CF_TOKEN!,
  hetznerToken: process.env.HETZNER_TOKEN!,
  environment: 'production',
  letsEncryptEmail: 'certs@example.com',
  publicUrl: 'cloudly.example.com',
  publicPort: 443,
  mongoDescriptor: {
    mongoDbUrl: process.env.MONGO_URL!,
    mongoDbName: 'cloudly',
    mongoDbUser: process.env.MONGO_USER!,
    mongoDbPass: process.env.MONGO_PASS!
  }
 };
 ```
-Focusing on practical applications, try extending these interfaces to suit additional requirements in your projects. Engage actively with the module community, or contribute new ideas to enhance the breadth and depth of this interface library. Explore the integration patterns showcased here and contribute toward a sophisticated cloud-native development framework.
+## 🎯 Advanced Features
 ### Generic Request Handler
 ```typescript
 import { ITypedRequest } from '@serve.zone/interfaces';
 class RequestHandler {
  async handle<T extends ITypedRequest>(
    request: T['request']
  ): Promise<T['response']> {
    // Type-safe request handling
    return this.processRequest(request);
  }
 }
 ```
 ### Discriminated Unions
 ```typescript
 import { IDeploymentStatus } from '@serve.zone/interfaces';
 function handleStatus(status: IDeploymentStatus) {
  switch (status.type) {
    case 'pending':
      console.log('Deployment pending...');
      break;
    case 'running':
      console.log(`Running on ${status.serverId}`);
      break;
    case 'failed':
      console.log(`Failed: ${status.error}`);
      break;
  }
 }
 ```
 ### Extending Interfaces
 ```typescript
 import { IService } from '@serve.zone/interfaces';
 interface IExtendedService extends IService {
  customMetadata: {
    team: string;
    costCenter: string;
    sla: 'standard' | 'premium';
  };
 }
 ```
 ## 🔄 Version Compatibility
 | @serve.zone/interfaces | @serve.zone/cloudly | @serve.zone/api | @serve.zone/cli |
 |------------------------|---------------------|-----------------|-----------------|
 | 5.x                    | 5.x                 | 5.x             | 5.x             |
 | 4.x                    | 4.x                 | 4.x             | 4.x             |
 | 3.x                    | 3.x                 | 3.x             | 3.x             |
 ## 📖 Interface Documentation
 All interfaces include comprehensive JSDoc comments:
 ```typescript
 /**
 * Represents a cluster configuration
 * @interface ICluster
 */
 export interface ICluster {
  /**
   * Unique identifier for the cluster
   * @type {string}
   */
  id: string;
  /**
   * Cluster configuration data
   * @type {IClusterData}
   */
  data: IClusterData;
 }
 ```
 ## 🛠️ Development Tips
 ### Import Organization
 ```typescript
 // Group imports by category
 import { 
  // Data models
  ICluster,
  IService,
  IImage,
  // Requests
  IRequest_CreateCluster,
  IRequest_DeployService,
  // Configuration
  ICloudlyConfig,
  IReverseProxyConfig
 } from '@serve.zone/interfaces';
 ```
 ### Type Guards
 ```typescript
 import { IService, ICluster } from '@serve.zone/interfaces';
 function isService(entity: IService | ICluster): entity is IService {
  return 'imageId' in entity.data;
 }
 ```
 ## License and Legal Information
--- a/ts_interfaces/requests/service.ts
+++ b/ts_interfaces/requests/service.ts
@@ -40,24 +40,7 @@ extends plugins.typedrequestInterfaces.implementsTR<
  method: 'createService';
  request: {
    identity: IIdentity;
-    name: string;
+    serviceData: IService['data'];
    description: string;
    imageId: string;
    imageVersion: string;
    environment: { [key: string]: string };
    secretBundleId: string;
    scaleFactor: number;
    balancingStrategy: 'round-robin' | 'least-connections';
    ports: {
      web: number;
      custom?: { [domain: string]: string };
    };
    resources?: IServiceRessources;
    domains: {
      name: string;
      port?: number;
      protocol?: 'http' | 'https' | 'ssh';
    }[];
  };
  response: {
    service: IService;
@@ -73,36 +56,19 @@ extends plugins.typedrequestInterfaces.implementsTR<
  request: {
    identity: IIdentity;
    serviceId: string;
-    name: string;
+    serviceData: IService['data'];
    description: string;
    imageId: string;
    imageVersion: string;
    environment: { [key: string]: string };
    secretBundleId: string;
    scaleFactor: number;
    balancingStrategy: 'round-robin' | 'least-connections';
    ports: {
      web: number;
      custom?: { [domain: string]: string };
    };
    resources?: IServiceRessources;
    domains: {
      name: string;
      port?: number;
      protocol?: 'http' | 'https' | 'ssh';
    }[];
  };
  response: {
    service: IService;
  };
 }
-export interface IRequest_Any_Cloudly_DeleteService
+export interface IRequest_Any_Cloudly_DeleteServiceById
 extends plugins.typedrequestInterfaces.implementsTR<
  plugins.typedrequestInterfaces.ITypedRequest,
-  IRequest_Any_Cloudly_DeleteService
+  IRequest_Any_Cloudly_DeleteServiceById
 > {
-  method: 'deleteService';
+  method: 'deleteServiceById';
  request: {
    identity: IIdentity;
    serviceId: string;
--- a/ts_web/00_commitinfo_data.ts
+++ b/ts_web/00_commitinfo_data.ts
@@ -3,6 +3,6 @@
 */
 export const commitinfo = {
  name: '@serve.zone/cloudly',
-  version: '4.12.2',
+  version: '5.0.5',
  description: 'A comprehensive tool for managing containerized applications across multiple cloud providers using Docker Swarmkit, featuring web, CLI, and API interfaces.'
 }
Author	SHA1	Message	Date
Juergen Kunz	1580bb1585	5.0.5 Some checks failed Docker (tags) / security (push) Successful in 1m13s Details Docker (tags) / test (push) Failing after 7m12s Details Docker (tags) / release (push) Has been skipped Details Docker (tags) / metadata (push) Has been skipped Details	2025-08-18 21:11:28 +00:00
Juergen Kunz	af7fcf6c2e	fix(coreflow): Fix Coreflow identity lookup and response shape; improve API client tests and bump dependencies	2025-08-18 21:11:28 +00:00
Juergen Kunz	23c9e3f678	Enhance README for @serve.zone/interfaces: improve structure, add features, and clarify installation instructions	2025-08-18 03:16:28 +00:00
Juergen Kunz	7d4e766e9e	Enhance documentation for @serve.zone/api and @serve.zone/cli - Updated the README for @serve.zone/api to improve clarity and organization, adding sections for features, quick start, authentication, core operations, and advanced usage. - Improved the installation instructions and added examples for various operations including image management, cluster operations, and real-time updates. - Enhanced the @serve.zone/cli README with a focus on features, installation, quick start, core commands, and advanced usage. - Added detailed command examples for cluster management, service deployment, secret management, and DNS management. - Included sections for CI/CD integration and troubleshooting in both README files. - Improved formatting and added emojis for better readability and engagement.	2025-08-18 03:14:49 +00:00
Juergen Kunz	907f3e8320	Enhance Cloudly Configuration and Testing Setup - Updated README to include architecture overview and details on components. - Changed import paths in test helpers and test files to use the new Git zone packages. - Modified S3 bucket name in test setup for consistency. - Updated CloudlyConfig class to use more descriptive environment variable names for MongoDB and S3 configuration. - Adjusted ImageManager to retrieve the S3 bucket name from the configuration instead of hardcoding it.	2025-08-18 03:07:12 +00:00
Philipp Kunz	bc7a2ca5f1	5.0.4 Some checks failed Docker (tags) / security (push) Successful in 48s Details Docker (tags) / test (push) Successful in 1m56s Details Docker (tags) / metadata (push) Successful in 3s Details Docker (tags) / release (push) Failing after 14s Details	2025-04-25 18:20:18 +00:00
Philipp Kunz	77d911e47a	fix(platformservice/mta): Update getEmailStatus response schema: make details property optional	2025-04-25 18:20:18 +00:00
Philipp Kunz	b9c9c2d0a9	5.0.3 Some checks failed Docker (tags) / security (push) Successful in 49s Details Docker (tags) / test (push) Successful in 1m55s Details Docker (tags) / metadata (push) Successful in 3s Details Docker (tags) / release (push) Failing after 14s Details	2025-04-25 17:02:48 +00:00
Philipp Kunz	d5b91789d1	fix(mta): update email status response type in MTA platform service	2025-04-25 17:02:48 +00:00
Philipp Kunz	eb8350f453	5.0.2 Some checks failed Docker (tags) / security (push) Successful in 38s Details Docker (tags) / test (push) Successful in 1m56s Details Docker (tags) / metadata (push) Successful in 3s Details Docker (tags) / release (push) Failing after 13s Details	2025-04-25 16:34:01 +00:00
Philipp Kunz	b987ce27b8	fix(platformservice/mta): Refactor email status response in MTA service	2025-04-25 16:34:00 +00:00
Philipp Kunz	630e363e53	5.0.1 Some checks failed Docker (tags) / security (push) Successful in 48s Details Docker (tags) / test (push) Successful in 1m54s Details Docker (tags) / metadata (push) Successful in 3s Details Docker (tags) / release (push) Failing after 14s Details	2025-04-25 16:27:48 +00:00
Philipp Kunz	a602021952	fix(mta): Update email stats response interface in mta platform service to include totalEmailsSent, totalEmailsDelivered, totalEmailsBounced, averageDeliveryTimeMs, and lastUpdated timestamp.	2025-04-25 16:27:48 +00:00
Philipp Kunz	80585437a0	5.0.0 Some checks failed Docker (tags) / security (push) Successful in 47s Details Docker (tags) / test (push) Successful in 1m54s Details Docker (tags) / metadata (push) Successful in 3s Details Docker (tags) / release (push) Failing after 41s Details	2025-04-25 15:57:35 +00:00
Philipp Kunz	4674a20a2c	BREAKING CHANGE(ts_interfaces/platformservice/mta): Rename mta interfaces and upgrade dependency versions	2025-04-25 15:57:35 +00:00
Philipp Kunz	820cdfcd48	4.13.0 Some checks failed Docker (tags) / security (push) Successful in 52s Details Docker (tags) / test (push) Successful in 3m5s Details Docker (tags) / metadata (push) Successful in 8s Details Docker (tags) / release (push) Failing after 22s Details	2025-01-20 02:18:58 +01:00
Philipp Kunz	6e5dd9b05a	feat(service): Add support for service creation, update, and deletion.	2025-01-20 02:18:58 +01:00