1.1.5

npmextra.json

@@ -16,26 +16,37 @@
       "githost": "gitlab.com",
       "gitscope": "servezone/private",
       "gitrepo": "cloudly",
-      "description": "A cloud manager leveraging Docker Swarmkit for multi-cloud operations including DigitalOcean, Hetzner Cloud, and Cloudflare, with integration support and robust configuration management system.",
+      "description": "A comprehensive multi-cloud manager leveraging Docker Swarmkit to orchestrate containerized applications across various cloud services and integrate robust configuration and API management capabilities.",
       "npmPackagename": "@serve.zone/cloudly",
       "license": "UNLICENSED",
       "keywords": [
         "cloud management",
-        "Docker Swarmkit",
         "multi-cloud",
+        "Docker Swarmkit",
         "DigitalOcean",
         "Hetzner Cloud",
         "Cloudflare",
         "container orchestration",
-        "TypeScript",
-        "node.js",
-        "infrastructure automation",
-        "Cloudron",
         "configuration management",
         "SSL management",
-        "APIs",
+        "API integration",
+        "TypeScript",
+        "node.js",
+        "cloud integration",
+        "infrastructure automation",
         "devOps",
-        "cloud integration"
+        "cloud API client",
+        "system logging",
+        "secret management",
+        "CI/CD integration",
+        "task scheduling",
+        "frontend",
+        "backend",
+        "cli",
+        "web interface",
+        "cloud providers",
+        "security",
+        "logging"
       ]
     }
   },

package.json

@@ -1,8 +1,8 @@
 {
   "name": "@serve.zone/cloudly",
-  "version": "1.1.0",
+  "version": "1.1.5",
   "private": false,
-  "description": "A cloud manager leveraging Docker Swarmkit for multi-cloud operations including DigitalOcean, Hetzner Cloud, and Cloudflare, with integration support and robust configuration management system.",
+  "description": "A comprehensive multi-cloud manager leveraging Docker Swarmkit to orchestrate containerized applications across various cloud services and integrate robust configuration and API management capabilities.",
   "type": "module",
   "exports": {
     ".": "./dist/index.js",
@@ -26,47 +26,50 @@
     "@git.zone/tstest": "^1.0.90",
     "@git.zone/tswatch": "^2.0.23",
     "@push.rocks/tapbundle": "^5.0.23",
-    "@types/node": "^20.12.13"
+    "@types/node": "^20.14.6"
   },
   "dependencies": {
-    "@api.global/typedrequest": "3.0.28",
+    "@api.global/typedrequest": "3.0.30",
     "@api.global/typedserver": "^3.0.50",
     "@api.global/typedsocket": "^3.0.1",
     "@apiclient.xyz/cloudflare": "^6.0.1",
-    "@apiclient.xyz/digitalocean": "^1.0.5",
-    "@apiclient.xyz/hetznercloud": "^1.0.18",
+    "@apiclient.xyz/docker": "^1.2.2",
+    "@apiclient.xyz/hetznercloud": "^1.2.0",
     "@apiclient.xyz/slack": "^3.0.9",
     "@design.estate/dees-catalog": "^1.0.289",
     "@design.estate/dees-domtools": "^2.0.57",
     "@design.estate/dees-element": "^2.0.34",
     "@git.zone/tsrun": "^1.2.37",
     "@push.rocks/early": "^4.0.3",
-    "@push.rocks/npmextra": "^5.0.13",
+    "@push.rocks/npmextra": "^5.0.23",
     "@push.rocks/projectinfo": "^5.0.1",
     "@push.rocks/qenv": "^6.0.5",
-    "@push.rocks/smartacme": "^4.0.8",
-    "@push.rocks/smartbucket": "^3.0.9",
+    "@push.rocks/smartacme": "^5.0.0",
+    "@push.rocks/smartbucket": "^3.0.20",
     "@push.rocks/smartcli": "^4.0.11",
-    "@push.rocks/smartdata": "^5.2.1",
+    "@push.rocks/smartclickhouse": "^2.0.17",
+    "@push.rocks/smartdata": "^5.2.6",
     "@push.rocks/smartdelay": "^3.0.5",
     "@push.rocks/smartexit": "^1.0.23",
-    "@push.rocks/smartfile": "^11.0.15",
+    "@push.rocks/smartfile": "^11.0.20",
     "@push.rocks/smartguard": "^3.0.2",
     "@push.rocks/smartjson": "^5.0.19",
     "@push.rocks/smartjwt": "^2.0.4",
-    "@push.rocks/smartlog": "^3.0.6",
-    "@push.rocks/smartlog-destination-clickhouse": "^1.0.11",
+    "@push.rocks/smartlog": "^3.0.7",
+    "@push.rocks/smartlog-destination-clickhouse": "^1.0.13",
     "@push.rocks/smartpath": "^5.0.18",
     "@push.rocks/smartpromise": "^4.0.3",
     "@push.rocks/smartrequest": "^2.0.22",
     "@push.rocks/smartrx": "^3.0.7",
     "@push.rocks/smartssh": "^2.0.1",
+    "@push.rocks/smartstate": "^2.0.17",
+    "@push.rocks/smartstream": "^3.0.44",
     "@push.rocks/smartstring": "^4.0.15",
     "@push.rocks/smartunique": "^3.0.9",
     "@push.rocks/taskbuffer": "^3.0.2",
     "@push.rocks/webjwt": "^1.0.9",
-    "@serve.zone/interfaces": "^1.0.56",
-    "@tsclass/tsclass": "^4.0.54"
+    "@serve.zone/interfaces": "^1.0.74",
+    "@tsclass/tsclass": "^4.0.60"
   },
   "files": [
     "ts/**/*",
@@ -93,20 +96,31 @@
   "homepage": "https://gitlab.com/servezone/private/cloudly#readme",
   "keywords": [
     "cloud management",
-    "Docker Swarmkit",
     "multi-cloud",
+    "Docker Swarmkit",
     "DigitalOcean",
     "Hetzner Cloud",
     "Cloudflare",
     "container orchestration",
-    "TypeScript",
-    "node.js",
-    "infrastructure automation",
-    "Cloudron",
     "configuration management",
     "SSL management",
-    "APIs",
+    "API integration",
+    "TypeScript",
+    "node.js",
+    "cloud integration",
+    "infrastructure automation",
     "devOps",
-    "cloud integration"
+    "cloud API client",
+    "system logging",
+    "secret management",
+    "CI/CD integration",
+    "task scheduling",
+    "frontend",
+    "backend",
+    "cli",
+    "web interface",
+    "cloud providers",
+    "security",
+    "logging"
   ]
 }

readme.hints.md

@@ -0,0 +1,10 @@
+- This repository contains 4 projects around serve.zone
+  - the cloudly backend under ts/*
+  - the cloudly frontend under ts_web/*
+  - the api client under ts_apiclient
+  - the cli client under ts_cliclient
+
+- the easiest method to spawn up a cloudly instance is to use the docker image:
+  `code.foss.global/serve.zone/cloudly:latest`
+
+- Note: the exports are defined in the package.json.

readme.md

@@ -1,21 +1,28 @@
 # @serve.zone/cloudly
-A cloud manager utilizing Docker Swarmkit, designed for operations on Cloudron, and supports various cloud platforms like DigitalOcean, Hetzner Cloud, and Cloudflare.
+
+A comprehensive multi-cloud manager leveraging Docker Swarmkit for orchestrating containerized applications and integrating various cloud services like DigitalOcean, Hetzner Cloud, and Cloudflare, with robust configuration and API management capabilities.
 
 ## Install
+
 To install `@serve.zone/cloudly`, run the following command in your terminal:
+
 ```bash
 npm install @serve.zone/cloudly --save
 ```
+
 This will install the package and add it to your project's `package.json` dependencies.
 
 ## Usage
+
 `@serve.zone/cloudly` is designed to help you manage and configure cloud environments. This package provides a comprehensive TypeScript and ESM-based interface for interacting with various cloud services, including Docker Swarmkit cluster management, and integration with cloud providers such as DigitalOcean, Hetzner Cloud, and Cloudflare.
 
 ### Getting Started
+
 Before diving into the specifics, ensure your environment is properly set up. This includes having Node.js installed (preferably the latest LTS version), and if you are working in a TypeScript project, ensure TypeScript is configured.
 
 #### Initializing Cloudly
-First, import `Cloudly` class from the package and initialize it as shown below:
+
+First, import the `Cloudly` class from the package and initialize it as shown below:
 
 ```typescript
 import { Cloudly } from '@serve.zone/cloudly';
@@ -26,6 +33,7 @@ const myCloudlyInstance = new Cloudly();
 The `Cloudly` class is the entry point to using the library features. It prepares the environment for configuring the cloud services.
 
 #### Configuration
+
 Configuration plays a pivotal role in how `@serve.zone/cloudly` operates. The library expects certain configurations to be provided, which can include credentials for cloud services, database connections, etc.
 
 For example, to configure a connection to MongoDB, specify your MongoDB details as shown:
@@ -38,16 +46,22 @@ const myCloudlyConfig = {
         mongoDbUser: 'myUser',
         mongoDbPass: 'myPassword',
     },
-    // Additional configuration values...
+    cfToken: 'your_cloudflare_api_token',
+    environment: 'development',
+    letsEncryptEmail: 'lets_encrypt_email@example.com',
+    publicUrl: 'example.com',
+    publicPort: 8443,
+    hetznerToken: 'your_hetzner_api_token',
 };
 
 const myCloudlyInstance = new Cloudly(myCloudlyConfig);
 ```
 
-#### Managing Docker Swarmkit Cluster
+### Managing Docker Swarmkit Clusters
+
 Cloudly allows managing Docker Swarmkit clusters through an abstracted interface, simplifying operations such as deployment and scaling. Below are examples to demonstrate these capabilities.
 
-### Example: Start a Cloudly Instance and Add a Cluster
+#### Example: Initializing a Cloudly Instance and Adding a Cluster
 
 ```typescript
 import { Cloudly, ClusterManager } from '@serve.zone/cloudly';
@@ -65,7 +79,7 @@ async function main() {
         letsEncryptEmail: 'lets_encrypt_email@example.com',
         publicUrl: 'example.com',
         publicPort: 8443,
-        hetznerToken: 'your_hetzner_api_token'
+        hetznerToken: 'your_hetzner_api_token',
     };
 
     const myCloudlyInstance = new Cloudly(myCloudlyConfig);
@@ -88,10 +102,15 @@ async function main() {
 
     console.log('Cluster added:', newCluster);
 }
+
 main();
 ```
 
-### Example: Manage Cloudflare DNS Records
+### Additional Use Cases
+
+#### Managing Cloudflare DNS Records
+
+You can manage Cloudflare DNS records using the `CloudflareConnector` provided by Cloudly.
 
 ```typescript
 import { Cloudly, CloudflareConnector } from '@serve.zone/cloudly';
@@ -109,7 +128,7 @@ async function manageDNSRecords() {
         letsEncryptEmail: 'lets_encrypt_email@example.com',
         publicUrl: 'example.com',
         publicPort: 8443,
-        hetznerToken: 'your_hetzner_api_token'
+        hetznerToken: 'your_hetzner_api_token',
     };
 
     const myCloudlyInstance = new Cloudly(myCloudlyConfig);
@@ -135,7 +154,9 @@ async function manageDNSRecords() {
 manageDNSRecords();
 ```
 
-### Example: Integrate with DigitalOcean
+#### Integrating with DigitalOcean
+
+Integrate with DigitalOcean to manage droplets and other resources.
 
 ```typescript
 import { Cloudly, DigitalOceanConnector } from '@serve.zone/cloudly';
@@ -153,7 +174,7 @@ async function manageDroplet() {
         letsEncryptEmail: 'lets_encrypt_email@example.com',
         publicUrl: 'example.com',
         publicPort: 8443,
-        hetznerToken: 'your_hetzner_api_token'
+        hetznerToken: 'your_hetzner_api_token',
     };
 
     const myCloudlyInstance = new Cloudly(myCloudlyConfig);
@@ -180,8 +201,11 @@ manageDroplet();
 ```
 
 ### Using Cloudly Web Interface
+
 If your project includes a web interface to manage various sections like DNS, deployments, clusters, etc., you can use the provided elements and state management. Below is an example of setting up a dashboard using the components defined:
 
+#### Web Dashboard Example
+
 ```typescript
 import { commitinfo } from '../00_commitinfo_data.js';
 import * as plugins from '../plugins.js';
@@ -212,7 +236,7 @@ import { CloudlyViewServices } from './cloudly-view-services.js';
 
 declare global {
   interface HTMLElementTagNameMap {
-    'cvault-dashboard': CloudlyDashboard;
+    'cloudly-dashboard': CloudlyDashboard;
   }
 }
 
@@ -227,6 +251,7 @@ export class CloudlyDashboard extends DeesElement {
 
   constructor() {
     super();
+    document.title = `cloudly v${commitinfo.version}`;
     const subcription = appstate.dataState
       .select((stateArg) => stateArg)
       .subscribe((dataArg) => {
@@ -309,6 +334,10 @@ export class CloudlyDashboard extends DeesElement {
                 name: 'Backups',
                 element: CloudlyViewBackups,
               },
+              {
+                name: 'Fleet',
+                element: CloudlyViewBackups,
+              }
             ] as plugins.deesCatalog.IView[]}
           ></dees-simple-appdash>
         </dees-simple-login>
@@ -329,7 +358,7 @@ export class CloudlyDashboard extends DeesElement {
           action: async () => {
             await plugins.deesCatalog.DeesModal.createAndShow({
               heading: 'About',
-              content: html`configvault ${commitinfo.version}`,
+              content: html`cloudly ${commitinfo.version}`,
               menuOptions: [
                 {
                   name: 'close',
@@ -352,11 +381,12 @@ export class CloudlyDashboard extends DeesElement {
     if (loginState.jwt) {
       this.jwt = loginState.jwt;
       await simpleLogin.switchToSlottedContent();
-      await appstate.dataState.dispatchAction(appstate.getDataAction, null);
+      await appstate.dataState.dispatchAction(appstate.getAllDataAction, null);
     }
   }
 
   private async login(username: string, password: string) {
+    const domtools = await this.domtoolsPromise;
     console.log(`attempting to login...`);
     const simpleLogin = this.shadowRoot.querySelector('dees-simple-login');
     const form = simpleLogin.shadowRoot.querySelector('dees-form');
@@ -370,7 +400,7 @@ export class CloudlyDashboard extends DeesElement {
       this.jwt = state.jwt;
       form.setStatus('success', 'Logged in!');
       await simpleLogin.switchToSlottedContent();
-      await appstate.dataState.dispatchAction(appstate.getDataAction, null);
+      await appstate.dataState.dispatchAction(appstate.getAllDataAction, null);
     } else {
       form.setStatus('error', 'Login failed!');
       await domtools.convenience.smartdelay.delayFor(2000);
@@ -382,8 +412,6 @@ export class CloudlyDashboard extends DeesElement {
 }
 ```
 
-This script sets up a cloud management dashboard for interacting with various cloud services seamlessly. It covers creating clusters, managing DNS records, handling cloud-provider-specific resources, and much more. 
-
 With the examples provided above, you should now have a good understanding of how to use `@serve.zone/cloudly` to manage your cloud infrastructure programmatically. For deeper insights and additional features, refer to the documentation relevant to specific modules and methods used in your application.
 
 ## License and Legal Information

test/test.apiclient.ts

@@ -0,0 +1,24 @@
+import { tap, expect } from '@push.rocks/tapbundle';
+
+import * as cloudlyApiClient from '../ts_apiclient/index.js';
+
+let testClient: cloudlyApiClient.CloudlyApiClient;
+
+tap.test('should create a new cloudlyApiClient', async () => {
+  testClient = new cloudlyApiClient.CloudlyApiClient({
+    registerAs: 'api',
+    cloudlyUrl: 'http://localhost:3000',
+  });
+  await testClient.start();
+  expect(testClient).toBeTruthy();
+});
+
+tap.test('should trigger a server action', async () => {
+  
+})
+
+tap.test('should stop the apiclient', async () => {
+  await testClient.stop();
+})
+
+export default tap.start();

test/test.ts

@@ -10,20 +10,19 @@ import * as cloudly from '../ts/index.js';
 let testCloudly: cloudly.Cloudly;
 tap.test('first test', async () => {
   const cloudlyConfig: cloudly.ICloudlyConfig = {
-    cfToken: testQenv.getEnvVarOnDemand('CF_TOKEN'),
+    cfToken: await testQenv.getEnvVarOnDemand('CF_TOKEN'),
     environment: 'integration',
-    letsEncryptEmail: testQenv.getEnvVarOnDemand('LETSENCRYPT_EMAIL'),
-    publicUrl: testQenv.getEnvVarOnDemand('SERVEZONE_URL'),
-    publicPort: testQenv.getEnvVarOnDemand('SERVEZONE_PORT'),
+    letsEncryptEmail: await testQenv.getEnvVarOnDemand('LETSENCRYPT_EMAIL'),
+    publicUrl: await testQenv.getEnvVarOnDemand('SERVEZONE_URL'),
+    publicPort: await testQenv.getEnvVarOnDemand('SERVEZONE_PORT'),
     mongoDescriptor: {
-      mongoDbName: testQenv.getEnvVarOnDemand('MONGODB_DATABASE'),
-      mongoDbUser: testQenv.getEnvVarOnDemand('MONGODB_USER'),
-      mongoDbPass: testQenv.getEnvVarOnDemand('MONGODB_PASSWORD'),
-      mongoDbUrl: testQenv.getEnvVarOnDemand('MONGODB_URL'),
+      mongoDbName: await testQenv.getEnvVarOnDemand('MONGODB_DATABASE'),
+      mongoDbUser: await testQenv.getEnvVarOnDemand('MONGODB_USER'),
+      mongoDbPass: await testQenv.getEnvVarOnDemand('MONGODB_PASSWORD'),
+      mongoDbUrl: await testQenv.getEnvVarOnDemand('MONGODB_URL'),
     },
-    digitalOceanToken: testQenv.getEnvVarOnDemand('DIGITALOCEAN_TOKEN'),
   };
-  testCloudly = new cloudly.Cloudly(cloudlyConfig);
+  testCloudly = new cloudly.Cloudly();
   expect(testCloudly).toBeInstanceOf(cloudly.Cloudly);
 });
 

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/cloudly',
-  version: '1.1.0',
-  description: 'A cloud manager leveraging Docker Swarmkit for multi-cloud operations including DigitalOcean, Hetzner Cloud, and Cloudflare, with integration support and robust configuration management system.'
+  version: '1.1.5',
+  description: 'A comprehensive multi-cloud manager leveraging Docker Swarmkit to orchestrate containerized applications across various cloud services and integrate robust configuration and API management capabilities.'
 }

ts/00demo/demo.data.images.ts

@@ -0,0 +1,13 @@
+import * as plugins from '../plugins.js';
+
+export const demoImages: plugins.servezoneInterfaces.data.IImage[] = [
+  {
+    id: 'DemoImage1',
+    data: {
+      name: 'DemoImage1',
+      description: 'DemoImage1',
+      versions: [],
+    }
+  }
+];
+

ts/00demo/demo.data.secrets.ts

@@ -63,6 +63,8 @@ for (let i = 0; i < demoSecretGroups.length; i++) {
     id: `configBundleId${i + 1}`,
     data: {
       name: `Demo Config Bundle ${i + 1}`,
+      includedImages: [],
+      type: 'external',
       description: 'Demo Purpose',
       includedSecretGroupIds: [secretGroup.id],
       includedTags: secretGroup.data.tags,

ts/00demo/demo.data.users.ts

@@ -0,0 +1,19 @@
+import * as plugins from '../plugins.js';
+import * as paths from '../paths.js';
+import type { Cloudly } from '../classes.cloudly.js';
+
+export const getUsers = async (cloudlyRef: Cloudly) => {
+  const users: plugins.servezoneInterfaces.data.IUser[] = [];
+  const envAdminUser = await cloudlyRef.config.appData.waitForAndGetKey('servezoneAdminaccount');
+  if (envAdminUser) {
+    users.push({
+      id: 'envadmin',
+      data: {
+        username: envAdminUser.split(':')[0],
+        password: envAdminUser.split(':')[1],
+        role: 'admin',
+      },
+    });
+  }
+  return users;
+};

ts/00demo/index.ts

@@ -43,9 +43,23 @@ export const installDemoData = async (cloudlyRef: Cloudly) => {
   }
 
   const demoDataUsers = await import('./demo.data.users.js');
-  for (const user of demoDataUsers.users) {
+  for (const user of await demoDataUsers.getUsers(cloudlyRef)) {
     const userInstance = new cloudlyRef.authManager.CUser();
     Object.assign(userInstance, user);
     await userInstance.save();
   }
+
+  // ================================================================================
+  // IMAGES
+  const images = await cloudlyRef.imageManager.CImage.getInstances({});
+  for (const image of images) {
+    await image.delete();
+  }
+
+  const demoDataImages = await import('./demo.data.images.js');
+  for (const image of demoDataImages.demoImages) {
+    const imageInstance = new cloudlyRef.imageManager.CImage();
+    Object.assign(imageInstance, image);
+    await imageInstance.save();
+  }
 }

ts/classes.cloudly.ts

@@ -15,10 +15,10 @@ import { MongodbConnector } from './connector.mongodb/connector.js';
 
 // processes
 import { CloudlyCoreflowManager } from './manager.coreflow/coreflowmanager.js';
-import { ClusterManager } from './manager.cluster/clustermanager.js';
+import { ClusterManager } from './manager.cluster/classes.clustermanager.js';
 import { CloudlyTaskmanager } from './manager.task/taskmanager.js';
 import { CloudlySecretManager } from './manager.secret/classes.secretmanager.js'
-import { CloudlyServerManager } from './manager.server/servermanager.js';
+import { CloudlyServerManager } from './manager.server/classes.servermanager.js';
 import { ExternalApiManager } from './manager.status/statusmanager.js';
 import { ImageManager } from './manager.image/classes.imagemanager.js';
 import { logger } from './logger.js';

ts/classes.config.ts

@@ -11,9 +11,6 @@ export class CloudlyConfig {
   public appData: plugins.npmextra.AppData<plugins.servezoneInterfaces.data.ICloudlyConfig>;
   public data: plugins.servezoneInterfaces.data.ICloudlyConfig
 
-  // authentication and settings
-  public smartjwtInstance: plugins.smartjwt.SmartJwt;
-
 
   constructor(cloudlyRefArg: Cloudly) {
     this.cloudlyRef = cloudlyRefArg;
@@ -43,6 +40,7 @@ export class CloudlyConfig {
           useSsl: true,
         },
         sslMode: 'SERVEZONE_SSLMODE' as plugins.servezoneInterfaces.data.ICloudlyConfig['sslMode'],
+        servezoneAdminaccount: 'SERVEZONE_ADMINACCOUNT',
       },
       requiredKeys: [
         'cfToken',

ts/classes.server.ts

@@ -10,7 +10,8 @@ export class CloudlyServer {
   /**
    * a reference to the cloudly instance
    */
-  private cloudlyRef: Cloudly;
+  public cloudlyRef: Cloudly;
+  public additionalHandlers: plugins.typedserver.servertools.Handler[] = [];
 
   /**
    * the smartexpress server handling the actual requests
@@ -37,18 +38,24 @@ export class CloudlyServer {
    * init the reception instance
    */
   public async start() {
-    logger.log('info', `cloudly domain is ${this.cloudlyRef.config.data.publicUrl}`)
+    logger.log('info', `cloudly domain is ${this.cloudlyRef.config.data.publicUrl}`);
     let sslCert: plugins.smartacme.Cert;
 
     if (this.cloudlyRef.config.data.sslMode === 'letsencrypt') {
-      logger.log('info', `Using letsencrypt for ssl mode. Trying to obtain a certificate...`)
-      logger.log('info', `This might take 10 minutes...`)
+      logger.log('info', `Using letsencrypt for ssl mode. Trying to obtain a certificate...`);
+      logger.log('info', `This might take 10 minutes...`);
       sslCert = await this.cloudlyRef.letsencryptConnector.getCertificateForDomain(
         this.cloudlyRef.config.data.publicUrl
       );
-      logger.log('success', `Successfully obtained certificate for cloudly domain ${this.cloudlyRef.config.data.publicUrl}`)
+      logger.log(
+        'success',
+        `Successfully obtained certificate for cloudly domain ${this.cloudlyRef.config.data.publicUrl}`
+      );
     } else if (this.cloudlyRef.config.data.sslMode === 'external') {
-      logger.log('info', `Using external certificate for ssl mode, meaning cloudly is not in charge of ssl termination.`)
+      logger.log(
+        'info',
+        `Using external certificate for ssl mode, meaning cloudly is not in charge of ssl termination.`
+      );
     }
 
     interface IRequestGuardData {
@@ -72,11 +79,13 @@ export class CloudlyServer {
     this.typedServer = new plugins.typedserver.TypedServer({
       cors: true,
       forceSsl: false,
-      port: this.cloudlyRef.config.data.publicPort,
-      ...(sslCert ? {
-        privateKey: sslCert.privateKey,
-        publicKey: sslCert.publicKey,
-      } : {}),
+      port: this.cloudlyRef.config.data.publicPort,
+      ...(sslCert
+        ? {
+            privateKey: sslCert.privateKey,
+            publicKey: sslCert.publicKey,
+          }
+        : {}),
       injectReload: true,
       serveDir: paths.distServeDir,
       watch: true,
@@ -84,6 +93,10 @@ export class CloudlyServer {
       preferredCompressionMethod: 'gzip',
     });
     this.typedServer.typedrouter.addTypedRouter(this.typedrouter);
+    this.typedServer.server.addRoute(
+      '/curlfresh/:scriptname',
+      this.cloudlyRef.serverManager.curlfreshInstance.handler
+    );
     await this.typedServer.start();
   }
 

ts/connector.letsencrypt/connector.ts

@@ -34,7 +34,10 @@ export class LetsencryptConnector {
       },
       mongoDescriptor: this.cloudlyRef.config.data.mongoDescriptor,
     });
-    await this.smartacme.init();
+    await this.smartacme.init().catch(err => {
+      console.error('error in init', err);
+      console.log(`trying again in a few minutes`)
+    });
   }
 
   /**

ts/demo/demo.data.users.ts

@@ -1,9 +0,0 @@
-export const users = [
-  {
-    id: 'user1',
-    data: {
-      username: 'admin',
-      password: 'password',
-    }
-  }
-]

ts/index.ts

@@ -21,8 +21,10 @@ const runCli = async () => {
   );
 
   await cloudlyInstance.start();
-  const demoMod = await import('./demo/index.js');
+  const demoMod = await import('./00demo/index.js');
   demoMod.installDemoData(cloudlyInstance);
 };
 
 export { runCli, Cloudly };
+type ICloudlyConfig = plugins.servezoneInterfaces.data.ICloudlyConfig;
+export { type ICloudlyConfig }

ts/manager.auth/classes.authmanager.ts

@@ -30,6 +30,7 @@ export class CloudlyAuthManager {
   public async start() {
     // lets setup the smartjwtInstance
     this.smartjwtInstance = new plugins.smartjwt.SmartJwt();
+    await this.smartjwtInstance.init();
     const kvStore = await this.cloudlyRef.config.appData.getKvStore();
 
     const existingJwtKeys: plugins.tsclass.network.IJwtKeypair = await kvStore.readKey('jwtKeys');
@@ -51,7 +52,7 @@ export class CloudlyAuthManager {
           if (!user) {
             logger.log('warn', 'login failed');
           } else {
-            jwt = await this.cloudlyRef.config.smartjwtInstance.createJWT({
+            jwt = await this.smartjwtInstance.createJWT({
               userId: user.id,
               status: 'loggedIn',
             });
@@ -69,8 +70,12 @@ export class CloudlyAuthManager {
 
   public adminJwtGuard = new plugins.smartguard.Guard<{jwt: string}>(async (dataArg) => {
     const jwt = dataArg.jwt;
-    const jwtData: IJwtData = await this.cloudlyRef.config.smartjwtInstance.verifyJWTAndGetData(jwt);
+    const jwtData: IJwtData = await this.smartjwtInstance.verifyJWTAndGetData(jwt);
     const user = await this.CUser.getInstance({id: jwtData.userId});
-    return user.data.role === 'admin';
+    const isAdminBool = user.data.role === 'admin';
+    console.log(`user is admin: ${isAdminBool}`);
+    return isAdminBool;
+  }, {
+    failedHint: 'user is not admin.'
   })
 }

ts/manager.auth/classes.user.ts

@@ -1,13 +1,16 @@
 import * as plugins from '../plugins.js';
 
 @plugins.smartdata.managed()
-export class User extends plugins.smartdata.SmartDataDbDoc<User, User> {
+export class User extends plugins.smartdata.SmartDataDbDoc<
+  User,
+  plugins.servezoneInterfaces.data.IUser
+> {
   public static async findUserByUsernameAndPassword(usernameArg: string, passwordArg: string) {
     return await User.getInstance({
       data: {
         username: usernameArg,
         password: passwordArg,
-      }
+      },
     });
   }
 
@@ -20,5 +23,5 @@ export class User extends plugins.smartdata.SmartDataDbDoc<User, User> {
     role: 'admin' | 'user';
     username: string;
     password: string;
-  }
+  };
 }

ts/manager.cert/cert.ts

@@ -0,0 +1,5 @@
+import * as plugins from '../plugins.js';
+
+export class Cert extends plugins.smartdata.SmartDataDbDoc<> {
+
+}

ts/manager.cert/certmanager.ts

@@ -0,0 +1,14 @@
+import type { Cloudly } from '../classes.cloudly.js';
+import * as plugins from '../plugins.js';
+
+export class CertManager {
+  public cloudlyRef: Cloudly;
+
+  public get db() {
+    return this.cloudlyRef.mongodbConnector.smartdataDb;
+  }
+
+  constructor(cloudly: Cloudly) {
+    this.cloudlyRef = cloudly;
+  }
+}

ts/manager.cluster/classes.clustermanager.ts

@@ -3,7 +3,7 @@ import * as paths from '../paths.js';
 import { Cloudly } from '../classes.cloudly.js';
 import { logger } from '../logger.js';
 
-import { Cluster } from './cluster.js';
+import { Cluster } from './classes.cluster.js';
 
 export class ClusterManager {
   public ready = plugins.smartpromise.defer();
@@ -28,7 +28,6 @@ export class ClusterManager {
             name: dataArg.clusterName,
             jumpCode: plugins.smartunique.uniSimple('cluster'),
             jumpCodeUsedAt: null,
-            secretKey: plugins.smartunique.shortId(16),
             acmeInfo: null,
             cloudlyUrl: `https://${this.cloudlyRef.config.data.publicUrl}:${this.cloudlyRef.config.data.publicPort}/`,
             servers: [],
@@ -54,6 +53,17 @@ export class ClusterManager {
         };
       })
     );
+
+    // delete cluster
+    this.typedrouter.addTypedHandler<plugins.servezoneInterfaces.requests.cluster.IRequest_DeleteCluster>(
+      new plugins.typedrequest.TypedHandler('deleteCluster', async (reqDataArg, toolsArg) => {
+        await toolsArg.passGuards([this.cloudlyRef.authManager.adminJwtGuard], reqDataArg);
+        await this.deleteCluster(reqDataArg.clusterId);
+        return {
+          success: true,
+        };
+      })
+    );
   }
 
   public async init() {
@@ -86,9 +96,9 @@ export class ClusterManager {
     await this.ready.promise;
 
     return await Cluster.getInstance({
+      id: clusterIdentifier.clusterId,
       data: {
         name: clusterIdentifier.clusterName,
-        secretKey: clusterIdentifier.secretKey,
       },
     });
   }
@@ -128,4 +138,10 @@ export class ClusterManager {
     await clusterInstance.save();
     return clusterInstance;
   }
+
+  public async deleteCluster(clusterId: string) {
+    await this.ready.promise;
+    const clusterInstance = await Cluster.getInstance({ id: clusterId });
+    await clusterInstance.delete();
+  }
 }

ts/manager.coreflow/coreflowmanager.ts

@@ -26,8 +26,12 @@ export class CloudlyCoreflowManager {
 
         return {
           clusterIdentifier: {
+            clusterId: clusterConfig.id,
             clusterName: clusterConfig.data.name,
-            secretKey: clusterConfig.data.secretKey,
+            jwt: await this.cloudlyRef.authManager.smartjwtInstance.createJWT({
+              status: 'loggedIn',
+              userId: 'cluster:' + clusterConfig.id,  // TODO: create real users for clusters
+            })
           },
         };
       })
@@ -47,7 +51,8 @@ export class CloudlyCoreflowManager {
             );
           console.log('got cluster config and sending it back to coreflow');
           return {
-            configData: await clusterConfigSet.createSavableObject()
+            configData: await clusterConfigSet.createSavableObject(),
+            deploymentDirectives: [],
           };
         }
       )

ts/manager.image/classes.image.ts

@@ -1,12 +1,20 @@
 import * as plugins from '../plugins.js';
 import type { ImageManager } from './classes.imagemanager.js';
 
-@plugins.smartdata.Manager()
+@plugins.smartdata.managed()
 export class Image extends plugins.smartdata.SmartDataDbDoc<Image, plugins.servezoneInterfaces.data.IImage, ImageManager> {
   public static async create(imageDataArg: Partial<plugins.servezoneInterfaces.data.IImage['data']>) {
     const image = new Image();
-    image.id = plugins.smartunique.uni('image');
-    Object.assign(image.data, imageDataArg);
+    image.id = await this.getNewId();
+    console.log(imageDataArg);
+    Object.assign(image, {
+      data: {
+        name: imageDataArg.name,
+        description: imageDataArg.description,
+        versions: [],
+      },
+    });
+    console.log((Image as any).saveableProperties)
     await image.save();
     return image;
   }
@@ -18,4 +26,12 @@ export class Image extends plugins.smartdata.SmartDataDbDoc<Image, plugins.serve
   public data: plugins.servezoneInterfaces.data.IImage['data'];
 
   public async getVersions() {}
+
+  /**
+   * returns a storage path
+   * note: this is relative to the storage method defined by the imageManager
+   */
+  public async getStoragePath(versionStringArg: string) {
+    return `${this.data.name}:${versionStringArg}`.replace('/', '__')
+  }
 }

ts/manager.image/classes.imagemanager.ts

@@ -5,19 +5,54 @@ import { Image } from './classes.image.js';
 
 export class ImageManager {
   cloudlyRef: Cloudly;
+  public typedrouter = new plugins.typedrequest.TypedRouter();
+  public smartbucketInstance: plugins.smartbucket.SmartBucket;
+  public imageDir: plugins.smartbucket.Directory;
+  public dockerImageStore: plugins.docker.DockerImageStore;
+  
   get db() {
     return this.cloudlyRef.mongodbConnector.smartdataDb;
   }
-  public typedrouter = new plugins.typedrequest.TypedRouter();
 
   public CImage = plugins.smartdata.setDefaultManagerForDoc(this, Image);
 
-  smartbucketInstance: plugins.smartbucket.SmartBucket;
 
   constructor(cloudlyRefArg: Cloudly) {
     this.cloudlyRef = cloudlyRefArg;
 
     this.cloudlyRef.typedrouter.addTypedRouter(this.typedrouter);
+
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.image.IRequest_CreateImage>(
+        'createImage',
+        async (reqArg, toolsArg) => {
+          await toolsArg.passGuards([this.cloudlyRef.authManager.adminJwtGuard], reqArg);
+          const image = await this.CImage.create({
+            name: reqArg.name,
+            description: reqArg.description,
+            versions: [],
+          });
+          return {
+            image: await image.createSavableObject(),
+          };
+        }
+      )
+    )
+
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.image.IRequest_DeleteImage>(
+        'deleteImage',
+        async (reqArg, toolsArg) => {
+          await toolsArg.passGuards([this.cloudlyRef.authManager.adminJwtGuard], reqArg);
+          const image = await this.CImage.getInstance({
+            id: reqArg.imageId,
+          });
+          await image.delete();
+          return {};
+        }
+      )
+    );
+
     this.typedrouter.addTypedHandler(
       new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.image.IRequest_GetAllImages>(
         'getAllImages',
@@ -36,39 +71,35 @@ export class ImageManager {
     );
 
     this.typedrouter.addTypedHandler(
-      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.image.IRequest_CreateImage>(
-        'createImage',
-        async (reqArg) => {
-          const image = await this.CImage.create({
-            name: reqArg.name,
+      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.image.IRequest_PushImageVersion>(
+        'pushImageVersion',
+        async (reqArg, toolsArg) => {
+          const image = await this.CImage.getInstance({
+            id: reqArg.imageId,
           });
+          if (!image) {
+            throw new plugins.typedrequest.TypedResponseError('Image not found');
+          }
+          const imageVersion = reqArg.versionString;
+          const imagePushStream = reqArg.imageStream;
           return {
-            image: await image.createSavableObject(),
+            allowed: true,
           };
         }
       )
     );
 
     this.typedrouter.addTypedHandler(
-      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.image.IRequest_PushImage>(
-        'pushImage',
-        async (reqArg) => {
-          const pushStream = reqArg.imageStream;
-          return {};
-        }
-      )
-    );
-
-    this.typedrouter.addTypedHandler(
-      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.image.IRequest_PullImage>(
-        'pullImage',
+      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.image.IRequest_PullImageVersion>(
+        'pullImageVersion',
         async (reqArg) => {
           const image = await this.CImage.getInstance({
-            data: {
-              name: reqArg.name,
-            },
+              id: reqArg.imageId,
           });
-          const imageVersion = null;
+          const imageVersion = image.data.versions.find((version) => version.versionString === reqArg.versionString);
+          const readable = this.imageDir.fastGetStream({
+            path: await image.getStoragePath(reqArg.versionString),
+          }, 'webstream');
           const imageVirtualStream = new plugins.typedrequest.VirtualStream();
           return {
             imageStream: imageVirtualStream,
@@ -87,11 +118,9 @@ export class ImageManager {
     );
     const bucket = await this.smartbucketInstance.getBucketByName('cloudly-test');
     await bucket.fastPut({ path: 'test/test.txt', contents: 'hello' });
-  }
 
-  public async createImage(nameArg: string) {
-    const newImage = await this.CImage.create({
-      name: nameArg,
+    this.imageDir = await bucket.getDirectoryFromPath({
+      path: 'images',
     });
   }
 }

ts/manager.secret/classes.secretmanager.ts

@@ -38,7 +38,8 @@ export class CloudlySecretManager {
     this.typedrouter.addTypedHandler(
       new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.secret.IReq_Admin_GetConfigBundlesAndSecretGroups>(
         'adminGetConfigBundlesAndSecretGroups',
-        async (dataArg) => {
+        async (dataArg, toolsArg) => {
+          await toolsArg.passGuards([this.cloudlyRef.authManager.adminJwtGuard], dataArg);
           dataArg.jwt
           const secretBundles = await SecretBundle.getInstances({});
           const secretGroups = await SecretGroup.getInstances({});

ts/manager.server/classes.curlfresh.ts

@@ -0,0 +1,87 @@
+import { logger } from '../logger.js';
+import * as plugins from '../plugins.js';
+import type { CloudlyServerManager } from './classes.servermanager.js';
+
+export class CurlFresh {
+  public optionsArg = {
+    npmRegistry: 'https://registry.npmjs.org',
+  }
+  public scripts = {
+    'setup.sh': `#!/bin/bash
+
+# lets update the system and install curl
+# might be installed already, but entrypoint could have been wget
+apt-get update
+apt-get install -y --force-yes curl
+
+# Basic updating of the software lists
+echo 'debconf debconf/frontend select Noninteractive' | debconf-set-selections
+apt-get update
+apt-get upgrade -y --force-yes
+apt-get install -y --force-yes fail2ban curl git
+curl -sL https://deb.nodesource.com/setup_18.x | bash
+
+# Install docker
+curl -sSL https://get.docker.com/ | sh
+
+# Install default nodejs to run nodejs tools
+apt-get install -y nodejs zsh
+zsh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)" "" --unattended
+npm config set unsafe-perm true
+
+# lets install pnpm
+curl -fsSL https://get.pnpm.io/install.sh | sh -
+
+# lets make sure we use the correct npm registry
+bash -c "npm config set registry ${this.optionsArg.npmRegistry}"
+
+# lets install spark
+bash -c "pnpm install -g @serve.zone/spark"
+
+# lets install the spark daemon
+bash -c "spark installdaemon"
+
+# TODO: start spark with jump code
+`,
+  };
+
+  public serverManagerRef: CloudlyServerManager;
+  public curlFreshRoute: plugins.typedserver.servertools.Route;
+  public handler = new plugins.typedserver.servertools.Handler('ALL', async (req, res) => {
+    logger.log('info', 'curlfresh handler called. a server might be coming online soon :)');
+    const scriptname = req.params.scriptname;
+    switch(scriptname) {
+      case 'setup.sh':
+        logger.log('info', 'sending setup.sh');
+        res.type('application/x-sh');
+        res.send(this.scripts['setup.sh']);
+        break;
+      default:
+        res.send('no script found');
+        break;
+    }
+  });
+
+  constructor(serverManagerRefArg: CloudlyServerManager) {
+    this.serverManagerRef = serverManagerRefArg;
+  }
+  public async getServerUserData(): Promise<string> {
+    const sslMode = await this.serverManagerRef.cloudlyRef.config.appData.waitForAndGetKey('sslMode');
+    let protocol: 'http' | 'https';
+    if (sslMode === 'none') {
+      protocol = 'http';
+    } else {
+      protocol = 'https';
+    }
+  
+    const domain = await this.serverManagerRef.cloudlyRef.config.appData.waitForAndGetKey('publicUrl');
+    const port = await this.serverManagerRef.cloudlyRef.config.appData.waitForAndGetKey('publicPort');
+  
+    const serverUserData = `#cloud-config
+  runcmd:
+    - curl -o- ${protocol}://${domain}:${port}/curlfresh/setup.sh | sh
+  `
+    console.log(serverUserData);
+    return serverUserData;
+  };
+}

ts/manager.server/classes.servermanager.ts

@@ -1,11 +1,13 @@
 import * as plugins from '../plugins.js';
 import { Cloudly } from '../classes.cloudly.js';
-import { Cluster } from '../manager.cluster/cluster.js';
-import { Server } from './server.js';
+import { Cluster } from '../manager.cluster/classes.cluster.js';
+import { Server } from './classes.server.js';
+import { CurlFresh } from './classes.curlfresh.js';
 
 export class CloudlyServerManager {
   public cloudlyRef: Cloudly;
   public typedRouter = new plugins.typedrequest.TypedRouter();
+  public curlfreshInstance = new CurlFresh(this);
 
   public hetznerAccount: plugins.hetznercloud.HetznerAccount;
 
@@ -63,7 +65,8 @@ export class CloudlyServerManager {
           labels: {
             clusterId: cluster.id,
             priority: '1',
-          }
+          },
+          userData: await this.curlfreshInstance.getServerUserData()
         });
         const newServer = await Server.createFromHetznerServer(server);
         console.log(`cluster created new server for cluster ${cluster.id}`);

ts/manager.service/classes.service.ts

@@ -0,0 +1,12 @@
+import * as plugins from '../plugins.js';
+
+export class Service extends plugins.smartdata.SmartDataDbDoc<Service, plugins.servezoneInterfaces.data.IService, ServiceManager> {
+  
+  @plugins.smartdata.svDb()
+  public id: string;
+
+  @plugins.smartdata.svDb()
+  public data: plugins.servezoneInterfaces.data.IService['data'];
+
+
+}

ts/manager.service/classes.servicemanager.ts

@@ -0,0 +1,18 @@
+import type { Cloudly } from '../classes.cloudly.js';
+import * as plugins from '../plugins.js';
+import { Service } from './classes.service.js';
+
+export class ServiceManager {
+  public typedrouter = new plugins.typedrequest.TypedRouter();
+  public cloudlyRef: Cloudly;
+  
+  get db() {
+    return this.cloudlyRef.mongodbConnector.smartdataDb;
+  }
+
+  public CService = plugins.smartdata.setDefaultManagerForDoc(this, Service);
+
+  constructor(cloudlyRef: Cloudly) {
+    this.cloudlyRef = cloudlyRef;
+  }
+}

ts/plugins.ts

@@ -9,13 +9,13 @@ import * as typedsocket from '@api.global/typedsocket';
 
 export { typedrequest, typedsocket };
 
-// @mojoio scope
+// @apiclient.xyz scope
 import * as cloudflare from '@apiclient.xyz/cloudflare';
-import * as digitalocean from '@apiclient.xyz/digitalocean';
+import * as docker from '@apiclient.xyz/docker';
 import * as hetznercloud from '@apiclient.xyz/hetznercloud';
 import * as slack from '@apiclient.xyz/slack';
 
-export { cloudflare, digitalocean, hetznercloud, slack };
+export { cloudflare, docker, hetznercloud, slack };
 
 // @tsclass scope
 import * as tsclass from '@tsclass/tsclass';
@@ -29,6 +29,7 @@ import * as qenv from '@push.rocks/qenv';
 import * as smartacme from '@push.rocks/smartacme';
 import * as smartbucket from '@push.rocks/smartbucket';
 import * as smartcli from '@push.rocks/smartcli';
+import * as smartclickhouse from '@push.rocks/smartclickhouse';
 import * as smartdata from '@push.rocks/smartdata';
 import * as smartdelay from '@push.rocks/smartdelay';
 import * as smartexit from '@push.rocks/smartexit';
@@ -53,6 +54,7 @@ export {
   smartacme,
   smartbucket,
   smartcli,
+  smartclickhouse,
   smartdata,
   smartexit,
   smartdelay,

ts_apiclient/classes.cloudlyapiclient.ts

@@ -1,8 +1,10 @@
 import * as plugins from './plugins.js';
 
-export type TClientType = 'coreflow' | 'cli' | 'serverconfig';
+export type TClientType = 'api' | 'ci' | 'coreflow' | 'cli' | 'serverconfig';
 
-export class CloudlyClient {
+import { Image } from './classes.image.js';
+
+export class CloudlyApiClient {
   private cloudlyUrl: string;
   private registerAs: string;
 
@@ -18,9 +20,13 @@ export class CloudlyClient {
     plugins.servezoneInterfaces.requests.server.IRequest_TriggerServerAction['request']
   >();
 
-  constructor(registerAsArg: TClientType) {
-    this.cloudlyUrl = process.env.CLOUDLY_URL || 'https://cloudly.layer.io:443';
-    this.registerAs = registerAsArg;
+  constructor(optionsArg?: {
+    registerAs: TClientType;
+    cloudlyUrl?: string;
+  }) {
+    this.registerAs = optionsArg.registerAs;
+    this.cloudlyUrl =
+      optionsArg?.cloudlyUrl || process.env.CLOUDLY_URL || 'https://cloudly.layer.io:443';
 
     console.log(
       `creating LoleCloudlyClient: registering as ${this.registerAs} and target url ${this.cloudlyUrl}`
@@ -33,13 +39,6 @@ export class CloudlyClient {
       })
     );
 
-    this.typedrouter.addTypedHandler<plugins.servezoneInterfaces.requests.config.IRequest_Cloudly_Coreflow_PushClusterConfig>(
-      new plugins.typedrequest.TypedHandler('pushClusterConfig', async (dataArg) => {
-        this.configUpdateSubject.next(dataArg);
-        return {};
-      })
-    );
-
     this.typedrouter.addTypedHandler<plugins.servezoneInterfaces.requests.server.IRequest_TriggerServerAction>(
       new plugins.typedrequest.TypedHandler('triggerServerAction', async (dataArg) => {
         this.serverActionSubject.next(dataArg);
@@ -55,15 +54,20 @@ export class CloudlyClient {
       this.typedrouter,
       this.cloudlyUrl
     );
+    console.log(
+      `CloudlyCluent connected to cloudly at ${this.cloudlyUrl}. Remember to get an identity.`
+    );
   }
 
   public async stop() {
     await this.typedsocketClient.stop();
   }
 
+  public identity: plugins.servezoneInterfaces.data.IClusterIdentifier;
   public async getIdentityByJumpCode(
     jumpCodeArg: string,
-    tagConnection = false
+    tagConnection = false,
+    statefullIdentity = true
   ): Promise<plugins.servezoneInterfaces.data.IClusterIdentifier> {
     const identityRequest =
       this.typedsocketClient.createTypedRequest<plugins.servezoneInterfaces.requests.identity.IRequest_Any_Cloudly_CoreflowManager_GetIdentityByJumpCode>(
@@ -80,6 +84,10 @@ export class CloudlyClient {
       this.typedsocketClient.addTag('identity', identity);
     }
 
+    if (statefullIdentity) {
+      this.identity = identity;
+    }
+
     return identity;
   }
 
@@ -91,7 +99,7 @@ export class CloudlyClient {
         'getClusterConfig'
       );
     const response = await clusterConfigRequest.fire({
-      jwt: '', // TODO: do proper auth here
+      jwt: '',
       clusterIdentifier: identityArg,
     });
     return response.configData;
@@ -106,7 +114,7 @@ export class CloudlyClient {
       );
     const response = await serverConfigRequest.fire({
       jwt: '', // TODO: do proper auth here
-      serverId: '' // TODO: get server id here
+      serverId: '', // TODO: get server id here
     });
     return response.configData;
   }
@@ -116,7 +124,9 @@ export class CloudlyClient {
    * @param serviceNameArg
    * @param domainNameArg
    */
-  public async getCertificateForDomainOverHttps(domainNameArg: string): Promise<plugins.tsclass.network.ICert> {
+  public async getCertificateForDomainOverHttps(
+    domainNameArg: string
+  ): Promise<plugins.tsclass.network.ICert> {
     const typedCertificateRequest =
       this.typedsocketClient.createTypedRequest<plugins.servezoneInterfaces.requests.certificate.IRequest_Any_Cloudly_GetSslCertificate>(
         'getSslCertificate'
@@ -127,4 +137,9 @@ export class CloudlyClient {
     });
     return typedResponse.certificate;
   }
+
+  // Images
+  public async getImages() {
+    return Image.getImages(this);
+  }
 }

ts_apiclient/classes.image.ts

@@ -1,5 +1,84 @@
+import type { CloudlyApiClient } from './classes.cloudlyapiclient.js';
 import * as plugins from './plugins.js';
 
-export class Image {
-  public getImages() {}
+export class Image implements plugins.servezoneInterfaces.data.IImage {
+  public static async getImages(cloudlyClientRef: CloudlyApiClient) {
+    const getAllImagesTR = cloudlyClientRef.typedsocketClient.createTypedRequest<plugins.servezoneInterfaces.requests.image.IRequest_GetAllImages>(
+      'getAllImages'
+    );
+    const response = await getAllImagesTR.fire({
+      jwt: cloudlyClientRef.identity.jwt,
+    });
+    const resultImages: Image[] = [];
+    for (const image of response.images) {
+      const newImage = new Image(cloudlyClientRef);
+      Object.assign(newImage, image);
+      resultImages.push(newImage);
+    }
+    return resultImages;
+  }
+
+  // INSTANCE
+  cloudlyClientRef: CloudlyApiClient;
+
+  id: plugins.servezoneInterfaces.data.IImage['id'];
+  data: plugins.servezoneInterfaces.data.IImage['data'];
+
+  constructor(cloudlyClientRef: CloudlyApiClient) {
+    this.cloudlyClientRef = cloudlyClientRef;
+  }
+
+  /**
+   * updates the image data
+   */
+  public async update() {
+    const getVersionsTR = this.cloudlyClientRef.typedsocketClient.createTypedRequest<plugins.servezoneInterfaces.requests.image.IRequest_GetImageMetadata>(
+      'getImageMetadata'
+    );
+    const response = await getVersionsTR.fire({
+      jwt: this.cloudlyClientRef.identity.jwt,
+      imageId: this.id,
+    });
+    Object.assign(this, response.image);
+  }
+
+  /**
+   * pushes a new version of the image
+   * @param imageVersion 
+   * @param imageReadableArg 
+   */
+  public async pushImageVersion(imageVersion: string, imageReadableArg: ReadableStream<Uint8Array>): Promise<void> {
+    const done = plugins.smartpromise.defer();
+    const pullImageTR = this.cloudlyClientRef.typedsocketClient.createTypedRequest<plugins.servezoneInterfaces.requests.image.IRequest_PushImageVersion>(
+      'pushImageVersion'
+    );
+    const virtualStream = new plugins.typedrequest.VirtualStream();
+    const response = await pullImageTR.fire({
+      jwt: this.cloudlyClientRef.identity.jwt,
+      imageId: this.id,
+      versionString: '',
+      imageStream: virtualStream,
+    });
+    await virtualStream.readFromWebstream(imageReadableArg);
+    await done.promise;
+    await this.update();
+  };
+
+  /**
+   * pulls a version of the image
+   */
+  public async pullImageVersion(versionStringArg: string): Promise<ReadableStream<Uint8Array>> {
+    const pullImageTR = this.cloudlyClientRef.typedsocketClient.createTypedRequest<plugins.servezoneInterfaces.requests.image.IRequest_PullImageVersion>(
+      'pullImageVersion'
+    );
+    const response = await pullImageTR.fire({
+      jwt: this.cloudlyClientRef.identity.jwt,
+      imageId: this.id,
+      versionString: versionStringArg,
+    });
+    const imageStream = response.imageStream;
+    const webduplexStream = new plugins.webstream.WebDuplexStream({});
+    imageStream.writeToWebstream(webduplexStream.writable);
+    return webduplexStream.readable;
+  };
 }

ts_apiclient/classes.server.ts

@@ -0,0 +1,7 @@
+import * as plugins from './plugins.js';
+
+export class Server {
+  public static getServers() {
+    
+  }
+}

ts_apiclient/index.ts

@@ -1 +1 @@
-export * from './classes.cloudlyclient.js';
+export * from './classes.cloudlyapiclient.js';

ts_apiclient/plugins.ts

@@ -6,10 +6,14 @@ export {
 }
 
 // @push.rocks scope
+import * as smartpromise from '@push.rocks/smartpromise';
 import * as smartrx from '@push.rocks/smartrx';
+import * as webstream from '@push.rocks/smartstream/web';
 
 export {
+  smartpromise,
   smartrx,
+  webstream,
 }
 
 // @api.global scope

ts_web/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/cloudly',
-  version: '1.1.0',
-  description: 'A cloud manager leveraging Docker Swarmkit for multi-cloud operations including DigitalOcean, Hetzner Cloud, and Cloudflare, with integration support and robust configuration management system.'
+  version: '1.1.5',
+  description: 'A comprehensive multi-cloud manager leveraging Docker Swarmkit to orchestrate containerized applications across various cloud services and integrate robust configuration and API management capabilities.'
 }

ts_web/appstate.ts

@@ -5,7 +5,7 @@ const appstate = new plugins.deesDomtools.plugins.smartstate.Smartstate();
 export interface ILoginState {
   jwt: string;
 }
-export const loginStatePart = await appstate.getStatePart<ILoginState>(
+export const loginStatePart: plugins.smartstate.StatePart<unknown, ILoginState> = await appstate.getStatePart<ILoginState>(
   'login',
   { jwt: null },
   'persistent'
@@ -72,7 +72,7 @@ export const dataState = await appstate.getStatePart<IDataState>(
 );
 
 // Getting data
-export const getDataAction = dataState.createAction(async (statePartArg) => {
+export const getAllDataAction = dataState.createAction(async (statePartArg, partialArg?: 'secrets' | 'images') => {
   let currentState = statePartArg.getState();
   // Secrets
   const trGetSecrets =
@@ -88,6 +88,20 @@ export const getDataAction = dataState.createAction(async (statePartArg) => {
     ...response,
   };
 
+  // images
+  const trGetImages =
+    new domtools.plugins.typedrequest.TypedRequest<plugins.interfaces.requests.image.IRequest_GetAllImages>(
+      '/typedrequest',
+      'getAllImages'
+    );
+  const responseImages = await trGetImages.fire({
+    jwt: loginStatePart.getState().jwt,
+  });
+  currentState = {
+    ...currentState,
+    ...responseImages,
+  };
+
   // Clusters
   const trGetClusters =
     new domtools.plugins.typedrequest.TypedRequest<plugins.interfaces.requests.cluster.IRequest_GetAllClusters>(
@@ -120,7 +134,7 @@ export const createSecretGroupAction = dataState.createAction(
       secretBundles: [],
       secretGroups: [payloadArg],
     });
-    currentState = await dataState.dispatchAction(getDataAction, null);
+    currentState = await dataState.dispatchAction(getAllDataAction, null);
     return currentState;
     return currentState;
   }
@@ -139,7 +153,7 @@ export const deleteSecretGroupAction = dataState.createAction(
       secretBundleIds: [],
       secretGroupIds: [payloadArg.secretGroupId],
     });
-    currentState = await dataState.dispatchAction(getDataAction, null);
+    currentState = await dataState.dispatchAction(getAllDataAction, null);
     return currentState;
   }
 );
@@ -158,7 +172,53 @@ export const deleteSecretBundleAction = dataState.createAction(
       secretBundleIds: [payloadArg.configBundleId],
       secretGroupIds: [],
     });
-    currentState = await dataState.dispatchAction(getDataAction, null);
+    currentState = await dataState.dispatchAction(getAllDataAction, null);
+    return currentState;
+  }
+);
+
+// image actions
+export const createImageAction = dataState.createAction(
+  async (statePartArg, payloadArg: { imageName: string, description: string }) => {
+    let currentState = statePartArg.getState();
+    const trCreateImage =
+      new domtools.plugins.typedrequest.TypedRequest<plugins.interfaces.requests.image.IRequest_CreateImage>(
+        '/typedrequest',
+        'createImage'
+      );
+    const response = await trCreateImage.fire({
+      jwt: loginStatePart.getState().jwt,
+      name: payloadArg.imageName,
+      description: payloadArg.description,
+    });
+    currentState = {
+      ...currentState,
+      ...{
+        images: [...currentState.images, response.image],
+      },
+    };
+    return currentState;
+  }
+);
+
+export const deleteImageAction = dataState.createAction(
+  async (statePartArg, payloadArg: { imageId: string }) => {
+    let currentState = statePartArg.getState();
+    const trDeleteImage =
+      new domtools.plugins.typedrequest.TypedRequest<plugins.interfaces.requests.image.IRequest_DeleteImage>(
+        '/typedrequest',
+        'deleteImage'
+      );
+    const response = await trDeleteImage.fire({
+      jwt: loginStatePart.getState().jwt,
+      imageId: payloadArg.imageId,
+    });
+    currentState = {
+      ...currentState,
+      ...{
+        images: currentState.images.filter((image) => image.id !== payloadArg.imageId),
+      },
+    };
     return currentState;
   }
 );

ts_web/elements/cloudly-dashboard.ts

@@ -42,6 +42,7 @@ export class CloudlyDashboard extends DeesElement {
 
   constructor() {
     super();
+    document.title = `cloudly v${commitinfo.version}`;
     const subcription = appstate.dataState
       .select((stateArg) => stateArg)
       .subscribe((dataArg) => {
@@ -148,7 +149,7 @@ export class CloudlyDashboard extends DeesElement {
           action: async () => {
             await plugins.deesCatalog.DeesModal.createAndShow({
               heading: 'About',
-              content: html`configvault ${commitinfo.version}`,
+              content: html`cloudly ${commitinfo.version}`,
               menuOptions: [
                 {
                   name: 'close',
@@ -171,7 +172,7 @@ export class CloudlyDashboard extends DeesElement {
     if (loginState.jwt) {
       this.jwt = loginState.jwt;
       await simpleLogin.switchToSlottedContent();
-      await appstate.dataState.dispatchAction(appstate.getDataAction, null);
+      await appstate.dataState.dispatchAction(appstate.getAllDataAction, null);
     }
   }
 
@@ -190,7 +191,7 @@ export class CloudlyDashboard extends DeesElement {
       this.jwt = state.jwt;
       form.setStatus('success', 'Logged in!');
       await simpleLogin.switchToSlottedContent();
-      await appstate.dataState.dispatchAction(appstate.getDataAction, null);
+      await appstate.dataState.dispatchAction(appstate.getAllDataAction, null);
     } else {
       form.setStatus('error', 'Login failed!');
       await domtools.convenience.smartdelay.delayFor(2000);

ts_web/elements/cloudly-view-images.ts

@@ -37,35 +37,25 @@ export class CloudlyViewImages extends DeesElement {
     return html`
       <cloudly-sectionheading>Images</cloudly-sectionheading>
       <dees-table
-        heading1="SecretGroups"
-        heading2="decoded in client"
+        heading1="Images"
+        heading2="an image is needed for running a service"
         .data=${this.data.images}
-        .displayFunction=${(secretGroup: plugins.interfaces.data.ISecretGroup) => {
+        .displayFunction=${(image: plugins.interfaces.data.IImage) => {
           return {
-            name: secretGroup.data.name,
-            priority: secretGroup.data.priority,
-            tags: html`<dees-chips
-              .selectionMode=${'none'}
-              .selectableChips=${secretGroup.data.tags}
-            ></dees-chips>`,
-            key: secretGroup.data.key,
-            history: (() => {
-              const allHistory = [];
-              for (const environment in secretGroup.data.environments) {
-                allHistory.push(...secretGroup.data.environments[environment].history);
-              }
-              return allHistory.length;
-            })(),
+            id: image.id,
+            name: image.data.name,
+            description: image.data.description,
+            versions: image.data.versions.length,
           };
         }}
         .dataActions=${[
           {
-            name: 'add SecretGroup',
+            name: 'create Image',
             type: ['header', 'footer'],
             iconName: 'plus',
             actionFunc: async () => {
               plugins.deesCatalog.DeesModal.createAndShow({
-                heading: 'create new SecretGroup',
+                heading: 'create new Image',
                 content: html`
                   <dees-form>
                     <dees-input-text
@@ -78,50 +68,6 @@ export class CloudlyViewImages extends DeesElement {
                       .key=${'data.description'}
                       .value=${''}
                     ></dees-input-text>
-                    <dees-input-text
-                      .label=${'Secret Key (data.key)'}
-                      .key=${'data.key'}
-                      .value=${''}
-                    ></dees-input-text>
-                    <dees-table
-                      .heading1=${'Environments'}
-                      .heading2=${'keys need to be unique'}
-                      key="environments"
-                      .data=${[
-                        {
-                          environment: 'production',
-                          value: '',
-                        },
-                        {
-                          environment: 'staging',
-                          value: '',
-                        },
-                      ]}
-                      .dataActions=${[
-                        {
-                          name: 'add environment',
-                          iconName: 'plus',
-                          type: ['footer'],
-                          actionFunc: async (dataArg) => {
-                            dataArg.table.data.push({
-                              environment: 'new environment',
-                              value: '',
-                            });
-                            dataArg.table.requestUpdate('data');
-                          },
-                        },
-                        {
-                          name: 'delete environment',
-                          iconName: 'trash',
-                          type: ['inRow'],
-                          actionFunc: async (dataArg) => {
-                            dataArg.table.data.splice(dataArg.table.data.indexOf(dataArg.item), 1);
-                            dataArg.table.requestUpdate('data');
-                          },
-                        },
-                      ] as plugins.deesCatalog.ITableAction[]}
-                      .editableFields=${['environment', 'value']}
-                    ></dees-table>
                   </dees-form>
                 `,
                 menuOptions: [
@@ -138,24 +84,9 @@ export class CloudlyViewImages extends DeesElement {
                       const formData = await deesForm.collectFormData();
                       console.log(`Prepare saving of data:`);
                       console.log(formData);
-                      const environments: plugins.interfaces.data.ISecretGroup['data']['environments'] =
-                        {};
-                      for (const itemArg of formData['environments'] as any[]) {
-                        environments[itemArg.environment] = {
-                          value: itemArg.value,
-                          history: [],
-                          lastUpdated: Date.now(),
-                        };
-                      }
-                      await appstate.dataState.dispatchAction(appstate.createSecretGroupAction, {
-                        id: null,
-                        data: {
-                          name: formData['data.name'] as string,
-                          description: formData['data.description'] as string,
-                          key: formData['data.key'] as string,
-                          environments,
-                          tags: [],
-                        },
+                      await appstate.dataState.dispatchAction(appstate.createImageAction, {
+                        imageName: formData['data.name'] as string,
+                        description: formData['data.description'] as string,
                       });
                       await modalArg.destroy();
                     },
@@ -327,16 +258,16 @@ export class CloudlyViewImages extends DeesElement {
             iconName: 'trash',
             type: ['contextmenu', 'inRow'],
             actionFunc: async (
-              itemArg: plugins.deesCatalog.ITableActionDataArg<plugins.interfaces.data.ISecretGroup>
+              itemArg: plugins.deesCatalog.ITableActionDataArg<plugins.interfaces.data.IImage>
             ) => {
               plugins.deesCatalog.DeesModal.createAndShow({
-                heading: `Delete ${itemArg.item.data.key}`,
+                heading: `Delete Image "${itemArg.item.data.name}"`,
                 content: html`
-                  <div style="text-align:center">Do you really want to delete the secret?</div>
+                  <div style="text-align:center">Do you really want to delete the image?</div>
                   <div
                     style="font-size: 0.8em; color: red; text-align:center; padding: 16px; margin-top: 24px; border: 1px solid #444; font-family: Intel One Mono; font-size: 16px;"
                   >
-                    ${itemArg.item.data.key}
+                    ${itemArg.item.id}
                   </div>
                 `,
                 menuOptions: [
@@ -350,8 +281,8 @@ export class CloudlyViewImages extends DeesElement {
                     name: 'delete',
                     action: async (modalArg) => {
                       console.log(`Delete ${itemArg.item.id}`);
-                      await appstate.dataState.dispatchAction(appstate.deleteSecretGroupAction, {
-                        secretGroupId: itemArg.item.id,
+                      await appstate.dataState.dispatchAction(appstate.deleteImageAction, {
+                        imageId: itemArg.item.id,
                       });
                       await modalArg.destroy();
                     },

ts_web/elements/cloudly-view-secretbundles.ts

@@ -21,12 +21,12 @@ export class CloudlyViewSecretBundles extends DeesElement {
 
   constructor() {
     super();
-    const subecription = appstate.dataState
+    const subscription = appstate.dataState
       .select((stateArg) => stateArg)
       .subscribe((dataArg) => {
         this.data = dataArg;
       });
-    this.rxSubscriptions.push(subecription);
+    this.rxSubscriptions.push(subscription);
   }
 
   public static styles = [
@@ -144,7 +144,7 @@ export class CloudlyViewSecretBundles extends DeesElement {
           },
           {
             name: 'edit',
-            iconName: 'edit',
+            iconName: 'penToSquare',
             type: ['doubleClick', 'contextmenu', 'inRow'],
             actionFunc: async (actionDataArg) => {
               const modal = await plugins.deesCatalog.DeesModal.createAndShow({

ts_web/plugins.ts

@@ -13,7 +13,9 @@ export { deesDomtools, deesElement, deesCatalog };
 
 // @push.rocks scope
 import * as webjwt from '@push.rocks/webjwt';
+import * as smartstate from '@push.rocks/smartstate';
 
 export {
   webjwt,
+  smartstate,
 }