5.0.5

- 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.

changelog.md

@@ -1,5 +1,14 @@
 # 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
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serve.zone/cloudly",
-  "version": "5.0.4",
+  "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.3.2",
+    "@git.zone/tsbuild": "^2.6.7",
-    "@git.zone/tsbundle": "^2.2.5",
+    "@git.zone/tsbundle": "^2.5.1",
-    "@git.zone/tsdoc": "^1.4.4",
+    "@git.zone/tsdoc": "^1.5.1",
-    "@git.zone/tspublish": "^1.9.1",
+    "@git.zone/tspublish": "^1.10.3",
-    "@git.zone/tstest": "^1.0.96",
+    "@git.zone/tstest": "^2.3.5",
-    "@git.zone/tswatch": "^2.1.0",
+    "@git.zone/tswatch": "^2.2.1",
-    "@push.rocks/tapbundle": "^5.6.3",
+    "@types/node": "^22.0.0"
-    "@types/node": "^22.15.2"
   },
   "dependencies": {
     "@api.global/typedrequest": "3.1.10",
     "@api.global/typedrequest-interfaces": "^3.0.19",
-    "@api.global/typedserver": "^3.0.74",
+    "@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.8.0",
+    "@design.estate/dees-catalog": "^1.10.10",
-    "@design.estate/dees-domtools": "^2.3.2",
+    "@design.estate/dees-domtools": "^2.3.3",
-    "@design.estate/dees-element": "^2.0.42",
+    "@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.15.1",
+    "@push.rocks/smartdata": "^5.16.4",
     "@push.rocks/smartdelay": "^3.0.5",
     "@push.rocks/smartexit": "^1.0.23",
-    "@push.rocks/smartexpect": "^1.6.1",
+    "@push.rocks/smartexpect": "^2.5.0",
-    "@push.rocks/smartfile": "^11.2.0",
+    "@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.2.3",
-    "@push.rocks/smartrequest": "^2.1.0",
+    "@push.rocks/smartrequest": "^4.2.2",
     "@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": "^9.0.0"
+    "@tsclass/tsclass": "^9.2.0"
   },
   "files": [
     "ts/**/*",

readme.hints.md

@@ -8,4 +8,12 @@
   `code.foss.global/serve.zone/cloudly:latest`
 
 - Note: the exports are defined in the package.json.
-- For now, cloud wise only the setup with cloudron and hetzner cloud is supported.
+- 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

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,
+  mongoDescriptor: {
+    mongoDbUrl: process.env.MONGODB_URL,
+    mongoDbName: 'cloudly',
+    mongoDbUser: process.env.MONGODB_USER,
+    mongoDbPass: process.env.MONGODB_PASS,
+  }
+});
 
-async function manageClusters() {
+// Start the platform
-    const myCloudlyConfig = {
+await cloudly.start();
-        cfToken: 'your_cloudflare_api_token',
+console.log('🎉 Cloudly is running!');
-        environment: 'development',
-        mongoDescriptor: {
-            mongoDbUrl: 'mongodb+srv://<username>:<password>@<cluster>.mongodb.net/myFirstDatabase',
-            mongoDbName: 'myDatabase',
-            mongoDbUser: 'myUser',
-            mongoDbPass: 'myPassword',
-        },
-        letsEncryptEmail: 'lets_encrypt_email@example.com',
-        publicUrl: 'example.com',
-        publicPort: 8443,
-        hetznerToken: 'your_hetzner_api_token',
-    };
-
-    const myCloudlyInstance = new Cloudly(myCloudlyConfig);
-    await myCloudlyInstance.start();
-
-    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>
+  <cloudly-dashboard>
-            <dees-simple-appdash>
+    <cloudly-view-clusters></cloudly-view-clusters>
-                <!-- Define sections and elements -->
+    <cloudly-view-dns></cloudly-view-dns>
-                <cloudly-view-clusters></cloudly-view-clusters>
+    <cloudly-view-images></cloudly-view-images>
-                <cloudly-view-dns></cloudly-view-dns>
+  </cloudly-dashboard>
-                <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
 
@@ -348,4 +255,4 @@ Registered at District court Bremen HRB 35230 HB, Germany
 
 For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
 
-By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.
+By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.

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) {

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 () => {
-  const identity = await testClient.getIdentityByToken('test');
+  console.log('🔵 Test: Getting identity by token...');
-  expect(identity).toBeTruthy();
+  console.log(`  - Using token: 'test'`);
-  console.log(identity);
+  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();
+  } 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 () => {
-  image = await testClient.image.createImage({
+  console.log('🔵 Test: Creating and uploading image...');
-    name: 'test',
+  console.log(`  - Image name: 'test'`);
-    description: 'test'
+  console.log(`  - Image description: 'test'`);
-  });
+  
-  console.log('created image: ', image);
+  try {
-  expect(image).toBeInstanceOf(Image);
+    image = await testClient.image.createImage({
+      name: 'test',
+      description: 'test'
+    });
+    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 () => {
-  const imageStream = await helpers.getAlpineImageReadableStream();
+  console.log('🔵 Test: Uploading image version...');
-
+  console.log(`  - Version: 'v1.0.0'`);
-  await image.pushImageVersion('v1.0.0', imageStream);
+  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) => {

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';

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/cloudly',
-  version: '5.0.4',
+  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.'
 }

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'],

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(),
           };
-        },
+        }
-      ),
+      )
     );
   }
 }

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({

ts_apiclient/readme.md

@@ -1,186 +1,290 @@
-# @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({
-    tagConnection: true,
+  registerAs: 'api',
-    statefullIdentity: true
+  cloudlyUrl: 'https://cloudly.example.com:443'
-  });
+});
 
-  console.log(`Authenticated identity:`, identity);
+// Start the connection
-  return identity;
+await client.start();
-}
 
-const serviceToken = 'your_service_token';
+// Authenticate with a service token
-const identity = await authenticate(cloudlyClient, serviceToken);
+const identity = await client.getIdentityByToken('your-service-token', {
+  tagConnection: true,
+  statefullIdentity: true
+});
+
+console.log('🎉 Connected as:', identity.name);
 ```
 
-In this function, the `getIdentityByToken` method authenticates using a service token and acquires an identity object that includes user details and security claims.
+## 🔐 Authentication
 
-### Interacting with Cloudly Features
+### Service Token Authentication
-
-#### 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) {
+// Authenticate using a service token
-  // Creating a new image
+const identity = await client.getIdentityByToken(serviceToken, {
-  const newImage = await client.images.createImage({
+  tagConnection: true,        // Tag this connection with the identity
-    name: 'my_new_image',
+  statefullIdentity: true     // Maintain state across reconnections
-    description: 'A test image'
+});
-  });
-
-  console.log(`Created image:`, newImage);
-
-  // Uploading an image version
-  const imageStream = fetchYourImageStreamHere(); // Provide the source image stream
-  await newImage.pushImageVersion('1.0.0', imageStream);
-  console.log('Image version uploaded successfully.');
-}
-
-await manageImages(cloudlyClient, identity);
-
-// 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.
+### Identity Management
-
-#### Cluster Configuration
-
-Another powerful capability is managing clusters, which allows for orchestrating and configuring Docker Swarm clusters:
 
 ```typescript
-async function configureCluster(client: CloudlyApiClient, identity) {
+// Get current identity
-  // Fetching cluster configuration
+const currentIdentity = client.identity;
-  const clusterConfig = await client.getClusterConfigFromCloudlyByIdentity(identity);
-  console.log(`Cluster configuration retrieved:`, clusterConfig);
-}
 
-await configureCluster(cloudlyClient, identity);
+// Check permissions
+if (currentIdentity.permissions.includes('cluster:write')) {
+  // Perform cluster operations
+}
 ```
 
-The `getClusterConfigFromCloudlyByIdentity` method retrieved the configuration needed to set up and manage your clusters within the multi-cloud environment.
+## 📚 Core Operations
 
-### Advanced Communication via Typed Sockets
+### 🐳 Image Management
-
-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) {
+// Create an image entry
-  client.configUpdateSubject.subscribe({
+const image = await client.images.createImage({
-    next: (configData) => {
+  name: 'my-app',
-      console.log('Received configuration update:', configData);
+  description: 'Production application image'
-    }
+});
-  });
 
-  client.serverActionSubject.subscribe({
+// Push a new version
-    next: (actionRequest) => {
+const imageStream = fs.createReadStream('app.tar');
-      console.log('Server action requested:', actionRequest);
+await image.pushImageVersion('2.0.0', imageStream);
-    }
-  });
-}
 
-configureSocketCommunication(cloudlyClient);
+// List all images
+const images = await client.images.listImages();
 ```
 
-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.
+### 🌐 Cluster Operations
-
-### 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) {
+// Get cluster configuration
-  const certificate = await client.getCertificateForDomain({
+const clusterConfig = await client.getClusterConfigFromCloudlyByIdentity(identity);
-    domainName: domainName,
-    type: 'ssl',
-    identity: identity
-  });
 
-  console.log('Retrieved SSL Certificate:', certificate);
+// Deploy to cluster
-}
+await client.deployToCluster({
-
+  clusterName: 'production',
-const yourDomain = 'example.com';
+  serviceName: 'api-service',
-await retrieveCertificate(cloudlyClient, yourDomain, identity);
+  image: 'my-app:2.0.0',
+  replicas: 3
+});
 ```
 
-This example demonstrates fetching SSL certificates using given domain credentials and an authenticated identity.
+### 🔒 Certificate Management
-
-### 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) {
+// Request SSL certificate
-  await client.stop();
+const certificate = await client.getCertificateForDomain({
-  console.log('Cloudly API client disconnected gracefully.');
+  domainName: 'api.example.com',
-}
+  type: 'ssl',
+  identity: identity
+});
 
-await cleanup(cloudlyClient);
+// Use certificate in your application
+console.log('Certificate:', certificate.cert);
+console.log('Private Key:', certificate.key);
 ```
 
-By invoking the `stop` method, the API client securely terminates its connection to ensure no resources are left hanging, preventing potential memory leaks.
+### 🔐 Secret Management
 
-### Miscellaneous Features
+```typescript
+// Create secret group
+const secretGroup = await client.secrets.createSecretGroup({
+  name: 'api-secrets',
+  secrets: [
+    { key: 'DATABASE_URL', value: 'postgres://...' },
+    { key: 'REDIS_URL', value: 'redis://...' }
+  ]
+});
 
-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.
+// Retrieve secrets
+const secrets = await client.secrets.getSecretGroup('api-secrets');
+```
 
-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.
+## 🔄 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
+    });
+
+    // Create and deploy an image
+    const image = await client.images.createImage({
+      name: 'my-service',
+      description: 'Microservice application'
+    });
+
+    // Push image version
+    const stream = getImageStream(); // Your image stream
+    await image.pushImageVersion('1.0.0', stream);
+
+    // Deploy to cluster
+    await client.deployToCluster({
+      clusterName: 'production',
+      serviceName: 'my-service',
+      image: 'my-service:1.0.0',
+      replicas: 3,
+      environment: {
+        NODE_ENV: 'production'
+      }
+    });
+
+    console.log('✅ Deployment successful!');
+
+  } catch (error) {
+    console.error('❌ Error:', error);
+  } finally {
+    await client.stop();
+  }
+}
+
+main();
+```
 
 ## License and Legal Information
 
@@ -199,4 +303,4 @@ Registered at District court Bremen HRB 35230 HB, Germany
 
 For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
 
-By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.
+By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.

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
 
@@ -259,4 +355,4 @@ Registered at District court Bremen HRB 35230 HB, Germany
 
 For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
 
-By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.
+By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.

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) {
+  data: {
-    this.logger = new SmartLogger(logConfig);
+    name: 'api-service',
+    imageId: 'image-456',
+    imageVersion: '2.0.0',
+    environment: {
+      NODE_ENV: 'production'
+    },
+    scaleFactor: 3,
+    balancingStrategy: 'round-robin',
+    ports: {
+      web: 80,
+      metrics: 9090
+    },
+    domains: [
+      { name: 'api.example.com' }
+    ],
+    deploymentIds: [],
+    deploymentDirectiveIds: []
   }
-
+};
-  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.
+### 🔐 Authentication & Identity
 
-#### 3. Container Service Management
+Identity management interfaces:
-
-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';
+import { 
+  IIdentity, 
+  IServiceToken,
+  IPermission 
+} from '@serve.zone/interfaces';
 
-function defineService(): IService {
+const identity: IIdentity = {
-  return {
+  id: 'user-789',
-    id: 'unique-service-id',
+  name: 'service-account',
-    data: {
+  type: 'service',
-      name: 'my-container-service',
+  permissions: ['cluster:read', 'service:write'],
-      imageId: 'unique-image-id',
+  tokenHash: 'hashed-token',
-      imageVersion: '1.0.0',
+  metadata: {
-      environment: { KEY: 'VALUE' },
+    createdAt: new Date(),
-      secretBundleId: 'bundle-id',
+    lastAccess: new Date()
-      scaleFactor: 2,
+  }
-      balancingStrategy: 'round-robin',
+};
-      ports: { web: 80 },
-      domains: [{ name: 'example.com' }],
-      deploymentIds: [],
-      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.
+### 🌐 Network Configuration
 
-#### 4. Network Configuration and Routing
+Networking and routing 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 { 
+  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'
+  }
+};
+```
 
-  return await cloudlyClient.typedsocketClient.fireTypedRequest<IRequest_Any_Cloudly_GetCertificateForDomain>(request);
+## 📚 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
+    };
+    
+    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
 
@@ -220,4 +388,4 @@ Registered at District court Bremen HRB 35230 HB, Germany
 
 For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
 
-By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.
+By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.

ts_web/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/cloudly',
-  version: '5.0.4',
+  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.'
 }