4.7.0

.gitea/workflows/docker_tags.yaml

@@ -10,9 +10,10 @@ env:
   NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@/${{gitea.repository}}.git
   NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
   NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
-  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  # NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
-  NPMCI_LOGIN_DOCKER_GITEA: ${{ github.server_url }}|${{ gitea.repository_owner }}|${{ secrets.GITEA_TOKEN }}
+  # NPMCI_LOGIN_DOCKER_GITEA: ${{ github.server_url }}|${{ gitea.repository_owner }}|${{ secrets.GITEA_TOKEN }}
   NPMCI_LOGIN_DOCKER_DOCKERREGISTRY: ${{ secrets.NPMCI_LOGIN_DOCKER_DOCKERREGISTRY }}
+  NPMCI_SECRET01: ${{ secrets.NPMCI_SECRET01 }} 
 
 jobs:
   security:
@@ -74,7 +75,7 @@ jobs:
     if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
     runs-on: ubuntu-latest
     container:
-      image: code.foss.global/hosttoday/ht-docker-dbase:npmci
+      image: code.foss.global/host.today/ht-docker-dbase:npmci
 
     steps:
       - uses: actions/checkout@v3
@@ -89,8 +90,7 @@ jobs:
           npmci docker login
           npmci docker build
           npmci docker test
-          # npmci docker push 
+          npmci docker push code.foss.global
-          npmci docker push 
 
   metadata:
     needs: test

Dockerfile

@@ -1,6 +1,6 @@
 # gitzone dockerfile_service
 ## STAGE 1 // BUILD
-FROM code.foss.global/hosttoday/ht-docker-node:npmci as node1
+FROM code.foss.global/host.today/ht-docker-node:npmci as node1
 COPY ./ /app
 WORKDIR /app
 ARG NPMCI_TOKEN_NPM2
@@ -12,7 +12,7 @@ RUN pnpm run build
 
 # gitzone dockerfile_service
 ## STAGE 2 // install production
-FROM code.foss.global/hosttoday/ht-docker-node:npmci as node2
+FROM code.foss.global/host.today/ht-docker-node:npmci as node2
 WORKDIR /app
 COPY --from=node1 /app /app
 RUN rm -rf .pnpm-store
@@ -24,7 +24,7 @@ RUN rm -rf node_modules/ && pnpm install --prod
 
 
 ## STAGE 3 // rebuild dependencies for alpine
-FROM code.foss.global/hosttoday/ht-docker-node:alpinenpmci as node3
+FROM code.foss.global/host.today/ht-docker-node:alpine_npmci as node3
 WORKDIR /app
 COPY --from=node2 /app /app
 ARG NPMCI_TOKEN_NPM2
@@ -34,7 +34,7 @@ RUN pnpm config set store-dir .pnpm-store
 RUN pnpm rebuild -r
 
 ## STAGE 4 // the final production image with all dependencies in place
-FROM code.foss.global/hosttoday/ht-docker-node:alpine as node4
+FROM code.foss.global/host.today/ht-docker-node:alpine as node4
 WORKDIR /app
 COPY --from=node3 /app /app
 

changelog.md

@@ -1,5 +1,185 @@
 # Changelog
 
+## 2024-12-22 - 4.7.0 - feat(apiclient)
+Add method to flatten secret bundles into key-value objects.
+
+- SecretBundle: Implemented toFlatKeyValueObject method to flatten secret groups into key-value pairs.
+- Removed stale SecretManager class from apiclient.
+
+## 2024-12-22 - 4.6.0 - feat(cloudlyapiclient)
+Extend CloudlyApiClient with cluster, secretbundle, and secretgroup methods
+
+- Added methods to CloudlyApiClient for managing clusters: getClusterById, getClusters, createCluster.
+- Added methods to CloudlyApiClient for managing secret bundles: getSecretBundleById, getSecretBundles, createSecretBundle.
+- Added methods to CloudlyApiClient for managing secret groups: getSecretGroupById, getSecretGroups, createSecretGroup.
+
+## 2024-12-22 - 4.5.5 - fix(apiclient)
+Fixed image creation method in cloudlyApiClient
+
+- Corrected method call from 'images.createImage' to 'image.createImage' to ensure proper image creation.
+- Updated cluster retrieval methods and ensured proper API routes are being called.
+
+## 2024-12-21 - 4.5.4 - fix(ts_web)
+Fix action type and data fields in appstate for CRUD operations
+
+- Correct request method in createSecretGroupAction to accurately reflect the purpose.
+- Align the deleteSecretGroupAction and deleteSecretBundleAction request types with proper interfaces.
+- Ensure data payload matches backend requirements for secret group and secret bundle operations.
+
+## 2024-12-21 - 4.5.3 - fix(secret-management)
+Refactor secret management to use distinct secret bundle and group APIs. Introduce API client classes for secret bundles and groups.
+
+- Updated secret management logic to separate secret bundle and group APIs.
+- Implemented new API client classes for managing secret bundles and groups.
+- Fixed incorrect method usages for secret-related actions.
+
+## 2024-12-20 - 4.5.2 - fix(apiclient)
+Implemented IService interface in Service class and improved secret bundle documentation.
+
+- Implemented plugins.servezoneInterfaces.data.IService interface in the Service class within ts_apiclient.
+- Updated documentation comments for the type property in the ISecretBundle interface.
+
+## 2024-12-17 - 4.5.1 - fix(core)
+Updated dependencies in package.json to latest versions.
+
+- Bumped @git.zone/tswatch to version ^2.0.37
+- Bumped @types/node to version ^22.10.2
+- Bumped @design.estate/dees-catalog to version ^1.3.2
+- Bumped @push.rocks/smartfile to version ^11.0.23
+- Bumped @tsclass/tsclass to version ^4.2.0
+
+## 2024-12-14 - 4.5.0 - feat(services)
+Add service management functionalities
+
+- Integrated service-related API client methods including getServices, getServiceById, and createService.
+- Updated the deployment data structure in the service manager.
+- Enhanced service interface to incorporate additional fields for comprehensive data handling.
+- Ensured secure token generation for Cloudly authentication processes.
+
+## 2024-11-18 - 4.4.0 - feat(api-client)
+Add static method getImageById for Image class in api-client
+
+- Introduced a static method getImageById in the Image class.
+- Updated CloudlyApiClient to include the getImageById method in the images interface.
+
+## 2024-11-18 - 4.3.21 - fix(interfaces)
+Remove deprecated deployment directive and update related interfaces
+
+- Removed IDeploymentDirective from data and requests.
+- Updated IDeployment to remove references to directives.
+- Changed IRequest_Any_Cloudly_GetClusterConfig to return services instead of deployment directives.
+- Removed deploymentDirectiveIds from IService data structure.
+
+## 2024-11-18 - 4.3.20 - fix(apiclient)
+Ensure mandatory parameter in CloudlyApiClient constructor
+
+- Made the 'optionsArg' parameter mandatory in the constructor of CloudlyApiClient class.
+
+## 2024-11-18 - 4.3.19 - fix(docker)
+Fix improper Docker push command preventing push to the correct registry.
+
+- Corrected the docker push command in the '.gitea/workflows/docker_tags.yaml' file to push images to the 'code.foss.global' registry.
+
+## 2024-11-17 - 4.3.18 - fix(docker_tags)
+Updated Docker configuration to include NPM tokens.
+
+- Restored NPMCI_TOKEN_NPM and NPMCI_TOKEN_NPM2 environment variables in docker_tags.yaml for authentication purposes.
+
+## 2024-11-17 - 4.3.17 - fix(Dockerfile)
+Corrected docker base image tag in Dockerfile for alpine compatibility.
+
+- Updated Dockerfile to use the correct base image tag for Alpine.
+- Resolved any potential build issues related to incorrect image tag usage.
+
+## 2024-11-17 - 4.3.16 - fix(infrastructure)
+Correct Docker image path in Dockerfile for improved build consistency.
+
+- Dockerfile: Updated base image paths from 'code.foss.global/hosttoday/ht-docker-node' to 'code.foss.global/host.today/ht-docker-node'.
+
+## 2024-11-17 - 4.3.15 - fix(project setup)
+fixed incorrect configuration in npmextra.json
+
+- Removed unnecessary 'dockerBuildargEnvMap' entry for NPMCI_TOKEN_NPM2.
+- Corrected the githost and gitscope in gitzone module configuration.
+- Updated the license field to reflect the correct license.
+
+## 2024-11-16 - 4.3.14 - fix(docker tags)
+Comment out unused secret variables in docker_tags.yaml
+
+- Modified docker_tags.yaml to comment out unused secret variables related to NPM and GitHub tokens.
+
+## 2024-11-16 - 4.3.13 - fix(package)
+Updated package dependencies
+
+- Updated @design.estate/dees-catalog version to 1.3.1
+
+## 2024-11-06 - 4.3.12 - fix(workflow)
+Fix Docker image path in GitHub action workflow
+
+- Corrected the path of the Docker image used in the GitHub action workflow from 'code.foss.global/hosttoday/ht-docker-dbase:npmci' to 'code.foss.global/host.today/ht-docker-dbase:npmci'.
+
+## 2024-11-06 - 4.3.11 - fix(overall)
+Refactor and improve code consistency across all modules
+
+- Updated cloud configuration management for better reliability.
+- Enhanced security measures in the authentication and authorization processes.
+- Streamlined deployment logic in cluster management.
+- Refactored code to improve maintainability and readability.
+
+## 2024-11-06 - 4.3.10 - fix(dependencies)
+Updated dependencies and fixed Docker Alpine image retrieval issue in tests
+
+- Updated @push.rocks/tapbundle to version ^5.5.0 in devDependencies.
+- Updated @push.rocks/smartrequest to version ^2.0.23 in dependencies.
+- Ensured the Docker Alpine image is retrieved as a local tarball in cloudlyfactory.ts test helper.
+
+## 2024-11-06 - 4.3.9 - fix(test and dependencies)
+Corrected cloudlyUrl in test.apiclient and updated tapbundle dependency.
+
+- Fixed cloudlyUrl assignment in the test.apiclient to use the correct helper method.
+- Updated tapbundle dependency version from ^5.4.3 to ^5.4.4.
+
+## 2024-11-06 - 4.3.8 - fix(api client)
+Fixed localhost URL issue in test.client.ts
+
+- Changed the cloudlyUrl in test.client.ts from 'localhost' to '127.0.0.1' to ensure consistency in network requests.
+
+## 2024-11-06 - 4.3.7 - fix(tests)
+Refactored test setup for consistency and isolated config initialization.
+
+- test/helpers/cloudlyfactory.ts: Test configuration setup was refactored to ensure consistent initialization of cloudly configuration across tests.
+- test/test.apiclient.ts: Updated cloudlyApiClient test setup to use testCloudlyConfig for dynamic port allocation.
+
+## 2024-11-06 - 4.3.6 - fix(test)
+Enhance test helpers with dynamic Hetzner token retrieval.
+
+- Updated test/helpers/cloudlyfactory.ts to retrieve Hetzner token from environment variables.
+- Expanded docker_tags workflow to securely handle and pass new environment secrets.
+
+## 2024-11-06 - 4.3.5 - fix(helpers)
+Add missing sslMode configuration to Cloudly config.
+
+- Added the sslMode key with a value of 'none' to the Cloudly configuration object in test/helpers/cloudlyfactory.ts.
+
+## 2024-11-06 - 4.3.4 - fix(testing)
+Fixed Cloudly testing setup and dependencies
+
+- Updated devDependency @push.rocks/tapbundle version from ^5.3.0 to ^5.4.3 in package.json.
+- Updated devDependency @push.rocks/npmextra version from ^5.1.1 to ^5.1.2 in package.json.
+- Improved the Cloudly test suite setup to ensure proper initialization of MongoDB and S3 services.
+- Ensured asynchronous stopping and cleanup of MongoDB and S3 services post-test execution.
+
+## 2024-11-05 - 4.3.3 - fix(core)
+Fix configuration initialization by accepting a config argument
+
+- Configuration initialization now accepts an optional config argument
+- Updated test cloudly factory to use default public URL and port
+- Updated dependencies versions
+
+## 2024-11-05 - 4.3.2 - fix(npmextra)
+Updated npm registry URL in npmextra.json
+
+
 ## 2024-11-05 - 4.3.1 - fix(package)
 Update dependency version for @git.zone/tspublish
 

npmextra.json

@@ -2,23 +2,21 @@
   "npmci": {
     "npmGlobalTools": [],
     "npmAccessLevel": "public",
-    "npmRegistryUrl": "verdaccio.lossless.one",
+    "npmRegistryUrl": "verdaccio.lossless.digital",
     "dockerRegistryRepoMap": {
-      "registry.gitlab.com": "losslessone/services/servezone/cloudly"
+      "code.foss.global": "serve.zone/cloudly"
     },
-    "dockerBuildargEnvMap": {
+    "dockerBuildargEnvMap": {}
-      "NPMCI_TOKEN_NPM2": "NPMCI_TOKEN_NPM2"
-    }
   },
   "gitzone": {
     "projectType": "service",
     "module": {
-      "githost": "gitlab.com",
+      "githost": "code.foss.global",
-      "gitscope": "servezone/private",
+      "gitscope": "serve.zone",
       "gitrepo": "cloudly",
       "description": "A comprehensive tool for managing containerized applications across multiple cloud providers using Docker Swarmkit, featuring web, CLI, and API interfaces.",
       "npmPackagename": "@serve.zone/cloudly",
-      "license": "UNLICENSED",
+      "license": "MIT",
       "keywords": [
         "multi-cloud management",
         "Docker Swarmkit",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serve.zone/cloudly",
-  "version": "4.3.1",
+  "version": "4.7.0",
   "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",
@@ -27,9 +27,9 @@
     "@git.zone/tsdoc": "^1.4.2",
     "@git.zone/tspublish": "^1.7.7",
     "@git.zone/tstest": "^1.0.90",
-    "@git.zone/tswatch": "^2.0.25",
+    "@git.zone/tswatch": "^2.0.37",
-    "@push.rocks/tapbundle": "^5.3.0",
+    "@push.rocks/tapbundle": "^5.5.3",
-    "@types/node": "^22.8.7"
+    "@types/node": "^22.10.2"
   },
   "dependencies": {
     "@api.global/typedrequest": "3.1.10",
@@ -40,23 +40,23 @@
     "@apiclient.xyz/docker": "^1.2.7",
     "@apiclient.xyz/hetznercloud": "^1.2.0",
     "@apiclient.xyz/slack": "^3.0.9",
-    "@design.estate/dees-catalog": "^1.2.0",
+    "@design.estate/dees-catalog": "^1.3.2",
     "@design.estate/dees-domtools": "^2.0.64",
     "@design.estate/dees-element": "^2.0.39",
     "@git.zone/tsrun": "^1.3.3",
     "@push.rocks/early": "^4.0.3",
-    "@push.rocks/npmextra": "^5.0.23",
+    "@push.rocks/npmextra": "^5.1.2",
     "@push.rocks/projectinfo": "^5.0.1",
-    "@push.rocks/qenv": "^6.0.5",
+    "@push.rocks/qenv": "^6.1.0",
     "@push.rocks/smartacme": "^5.0.0",
-    "@push.rocks/smartbucket": "^3.0.23",
+    "@push.rocks/smartbucket": "^3.3.7",
     "@push.rocks/smartcli": "^4.0.11",
     "@push.rocks/smartclickhouse": "^2.0.17",
     "@push.rocks/smartdata": "^5.2.10",
     "@push.rocks/smartdelay": "^3.0.5",
     "@push.rocks/smartexit": "^1.0.23",
     "@push.rocks/smartexpect": "^1.2.1",
-    "@push.rocks/smartfile": "^11.0.21",
+    "@push.rocks/smartfile": "^11.0.23",
     "@push.rocks/smartguard": "^3.1.0",
     "@push.rocks/smartjson": "^5.0.19",
     "@push.rocks/smartjwt": "^2.2.1",
@@ -65,16 +65,16 @@
     "@push.rocks/smartlog-interfaces": "^3.0.2",
     "@push.rocks/smartpath": "^5.0.18",
     "@push.rocks/smartpromise": "^4.0.4",
-    "@push.rocks/smartrequest": "^2.0.22",
+    "@push.rocks/smartrequest": "^2.0.23",
     "@push.rocks/smartrx": "^3.0.7",
     "@push.rocks/smartssh": "^2.0.1",
     "@push.rocks/smartstate": "^2.0.19",
-    "@push.rocks/smartstream": "^3.2.4",
+    "@push.rocks/smartstream": "^3.2.5",
     "@push.rocks/smartstring": "^4.0.15",
     "@push.rocks/smartunique": "^3.0.9",
     "@push.rocks/taskbuffer": "^3.0.2",
     "@push.rocks/webjwt": "^1.0.9",
-    "@tsclass/tsclass": "^4.1.2"
+    "@tsclass/tsclass": "^4.2.0"
   },
   "files": [
     "ts/**/*",

test/helpers/cloudlyfactory.ts

@@ -3,25 +3,48 @@ const testQenv = new Qenv('./', './.nogit/');
 
 import * as cloudly from '../../ts/index.js';
 
+const stopFunctions: Array<() => Promise<void>> = [];
+
+const tapToolsNodeMod = await import('@push.rocks/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');
+stopFunctions.push(async () => {
+  await smarts3.stop();
+});
+
+export const testCloudlyConfig: cloudly.ICloudlyConfig = {
+  cfToken: await testQenv.getEnvVarOnDemand('CF_TOKEN'),
+  environment: 'integration',
+  letsEncryptEmail: 'test@serve.zone',
+  publicUrl: '127.0.0.1',
+  publicPort: '8080',
+  mongoDescriptor: await smartmongo.getMongoDescriptor(),
+  s3Descriptor: await smarts3.getS3Descriptor(),
+  sslMode: 'none',
+  ...(() => {
+    if (process.env.NPMCI_SECRET01) {
+      return {
+        hetznerToken: process.env.NPMCI_SECRET01,
+      };
+    }
+  })(),
+};
+
+await tapToolsNodeMod.tapNodeTools.testFileProvider.getDockerAlpineImageAsLocalTarball();
+
 export const createCloudly = async () => {
-  const cloudlyConfig: cloudly.ICloudlyConfig = {
+  const cloudlyInstance = new cloudly.Cloudly(testCloudlyConfig);
-    cfToken: await testQenv.getEnvVarOnDemand('CF_TOKEN'),
-    environment: 'integration',
-    letsEncryptEmail: await testQenv.getEnvVarOnDemand('LETSENCRYPT_EMAIL'),
-    publicUrl: await testQenv.getEnvVarOnDemand('SERVEZONE_URL'),
-    publicPort: await testQenv.getEnvVarOnDemand('SERVEZONE_PORT'),
-    mongoDescriptor: {
-      mongoDbName: await testQenv.getEnvVarOnDemand('MONGODB_DATABASE'),
-      mongoDbUser: await testQenv.getEnvVarOnDemand('MONGODB_USER'),
-      mongoDbPass: await testQenv.getEnvVarOnDemand('MONGODB_PASSWORD'),
-      mongoDbUrl: await testQenv.getEnvVarOnDemand('MONGODB_URL'),
-    },
-  };
-  const cloudlyInstance = new cloudly.Cloudly();
   return cloudlyInstance;
-}
+};
+
+export const stopCloudly = async () => {
+  await Promise.all(stopFunctions.map((stopFunction) => stopFunction()));
+};
 
 export const getEnvVarOnDemand = async (envVarName: string) => {
   return testQenv.getEnvVarOnDemand(envVarName);
-} 
+};
-

test/test.apiclient.ts

@@ -33,7 +33,7 @@ tap.preTask('should create a new machine user for testing', async () => {
 tap.test('should create a new cloudlyApiClient', async () => {
   testClient = new cloudlyApiClient.CloudlyApiClient({
     registerAs: 'api',
-    cloudlyUrl: `http://localhost:${await helpers.getEnvVarOnDemand('SERVEZONE_PORT')}`,
+    cloudlyUrl: `http://${helpers.testCloudlyConfig.publicUrl}:${helpers.testCloudlyConfig.publicPort}`,
   });
   await testClient.start();
   expect(testClient).toBeTruthy();
@@ -57,7 +57,7 @@ tap.test('should get an identity', async () => {
 
 let image: Image;
 tap.test('should create and upload an image', async () => {
-  image = await testClient.images.createImage({
+  image = await testClient.image.createImage({
     name: 'test',
     description: 'test'
   });
@@ -73,6 +73,7 @@ tap.test('should upload an image version', async () => {
 
 tap.test('should stop the apiclient', async (toolsArg) => {
   await toolsArg.delayFor(10000);
+  await helpers.stopCloudly();
   await testClient.stop();
   await testCloudly.stop();
 })

test/test.ts

@@ -14,8 +14,10 @@ tap.test('should init cloudly', async () => {
 });
 
 tap.test('should end the service', async (tools) => {
+  await tools.delayFor(5000);
+  await helpers.stopCloudly();
   await testCloudly.stop();
-  tools.delayFor(1000).then(() => process.exit())
+  tools.delayFor(1000).then(() => process.exit());
 });
 
 tap.start();

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/cloudly',
-  version: '4.3.1',
+  version: '4.7.0',
   description: 'A comprehensive tool for managing containerized applications across multiple cloud providers using Docker Swarmkit, featuring web, CLI, and API interfaces.'
 }

ts/classes.cloudly.ts

@@ -60,7 +60,9 @@ export class Cloudly {
 
   private readyDeferred = new plugins.smartpromise.Deferred();
 
-  constructor() {
+  private configOptions: plugins.servezoneInterfaces.data.ICloudlyConfig;
+  constructor(configArg?: plugins.servezoneInterfaces.data.ICloudlyConfig) {
+    this.configOptions = configArg;
     this.cloudlyInfo = new CloudlyInfo(this);
     this.config = new CloudlyConfig(this);
 
@@ -90,7 +92,7 @@ export class Cloudly {
    */
   public async start() {
     // config
-    await this.config.init();
+    await this.config.init(this.configOptions);
 
     // manageers
     await this.authManager.start();

ts/classes.config.ts

@@ -15,7 +15,7 @@ export class CloudlyConfig {
     this.cloudlyRef = cloudlyRefArg;
   }
 
-  public async init() {
+  public async init(configArg?: plugins.servezoneInterfaces.data.ICloudlyConfig) {
     this.appData =
       await plugins.npmextra.AppData.createAndInit<plugins.servezoneInterfaces.data.ICloudlyConfig>(
         {
@@ -54,6 +54,7 @@ export class CloudlyConfig {
             'environment',
             'mongoDescriptor',
           ],
+          overwriteObject: configArg,
         },
       );
 

ts/manager.cluster/classes.clustermanager.ts

@@ -38,12 +38,12 @@ export class ClusterManager {
         console.log(await cluster.createSavableObject());
         this.cloudlyRef.serverManager.ensureServerInfrastructure();
         return {
-          clusterConfig: await cluster.createSavableObject(),
+          cluster: await cluster.createSavableObject(),
         };
       }),
     );
 
-    this.typedrouter.addTypedHandler<plugins.servezoneInterfaces.requests.cluster.IRequest_GetAllClusters>(
+    this.typedrouter.addTypedHandler<plugins.servezoneInterfaces.requests.cluster.IReq_Any_Cloudly_GetClusters>(
       new plugins.typedrequest.TypedHandler('getAllClusters', async (dataArg) => {
         // TODO: do authentication here
         const clusters = await this.getAllClusters();
@@ -56,7 +56,7 @@ export class ClusterManager {
     );
 
     // delete cluster
-    this.typedrouter.addTypedHandler<plugins.servezoneInterfaces.requests.cluster.IRequest_DeleteCluster>(
+    this.typedrouter.addTypedHandler<plugins.servezoneInterfaces.requests.cluster.IReq_Any_Cloudly_DeleteClusterById>(
       new plugins.typedrequest.TypedHandler('deleteCluster', async (reqDataArg, toolsArg) => {
         await toolsArg.passGuards([this.cloudlyRef.authManager.adminIdentityGuard], reqDataArg);
         await this.deleteCluster(reqDataArg.clusterId);

ts/manager.secret/classes.secretmanager.ts

@@ -35,20 +35,71 @@ export class CloudlySecretManager {
     this.typedrouter = new plugins.typedrequest.TypedRouter();
     this.cloudlyRef.typedrouter.addTypedRouter(this.typedrouter);
 
-    this.typedrouter.addTypedHandler(
+    // secretbundle routes
-      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.secret.IReq_Admin_GetConfigBundlesAndSecretGroups>(
+    this.typedrouter.addTypedHandler<plugins.servezoneInterfaces.requests.secretbundle.IReq_GetSecretBundles>(
-        'adminGetConfigBundlesAndSecretGroups',
+      new plugins.typedrequest.TypedHandler(
+        'getSecretBundles',
         async (dataArg, toolsArg) => {
           await toolsArg.passGuards([this.cloudlyRef.authManager.adminIdentityGuard], dataArg);
           dataArg.identity.jwt;
           const secretBundles = await SecretBundle.getInstances({});
-          const secretGroups = await SecretGroup.getInstances({});
           return {
             secretBundles: [
               ...(await Promise.all(
                 secretBundles.map((configBundle) => configBundle.createSavableObject()),
               )),
             ],
+          };
+        },
+      ),
+    );
+
+    this.typedrouter.addTypedHandler<plugins.servezoneInterfaces.requests.secretbundle.IReq_CreateSecretBundle>(
+      new plugins.typedrequest.TypedHandler('createSecretBundle', async (dataArg) => {
+        const secretBundle = new SecretBundle();
+        secretBundle.id = plugins.smartunique.shortId(8);
+        secretBundle.data = dataArg.secretBundle.data;
+        await secretBundle.save();
+        return {
+          resultSecretBundle: await secretBundle.createSavableObject(),
+        };
+      }),
+    );
+
+    this.typedrouter.addTypedHandler<plugins.servezoneInterfaces.requests.secretbundle.IReq_UpdateSecretBundle>(
+      new plugins.typedrequest.TypedHandler('updateSecretBundle', async (dataArg) => {
+        const secretBundle = await SecretBundle.getInstance({
+          id: dataArg.secretBundle.id,
+        });
+        secretBundle.data = dataArg.secretBundle.data;
+        await secretBundle.save();
+        return {
+          resultSecretBundle: await secretBundle.createSavableObject(),
+        };
+      }),
+    );
+
+    this.typedrouter.addTypedHandler<plugins.servezoneInterfaces.requests.secretbundle.IReq_DeleteSecretBundleById>(
+      new plugins.typedrequest.TypedHandler('deleteSecretBundleById', async (dataArg) => {
+        const secretBundle = await SecretBundle.getInstance({
+          id: dataArg.secretBundleId,
+        });
+        await secretBundle.delete();
+        return {
+          ok: true,
+        };
+      }),
+    );
+
+    // secretgroup routes
+    this.typedrouter.addTypedHandler<plugins.servezoneInterfaces.requests.secretgroup.IReq_GetSecretGroups>(
+      new plugins.typedrequest.TypedHandler(
+        'getSecretGroups',
+        async (dataArg, toolsArg) => {
+          await toolsArg.passGuards([this.cloudlyRef.authManager.adminIdentityGuard], dataArg);
+          dataArg.identity.jwt;
+          const secretGroups = await SecretGroup.getInstances({});
+          return {
             secretGroups: [
               ...(await Promise.all(
                 secretGroups.map((secretGroup) => secretGroup.createSavableObject()),
@@ -59,50 +110,45 @@ export class CloudlySecretManager {
       ),
     );
 
-    this.typedrouter.addTypedHandler<plugins.servezoneInterfaces.requests.secret.IReq_Admin_CreateConfigBundlesAndSecretGroups>(
+    this.typedrouter.addTypedHandler<plugins.servezoneInterfaces.requests.secretgroup.IReq_CreateSecretGroup>(
-      new plugins.typedrequest.TypedHandler(
+      new plugins.typedrequest.TypedHandler('createSecretGroup', async (dataArg) => {
-        'adminCreateConfigBundlesAndSecretGroups',
+        const secretGroup = new SecretGroup();
-        async (dataArg) => {
+        secretGroup.id = plugins.smartunique.shortId(8);
-          for (const secretGroupObject of dataArg.secretGroups) {
+        secretGroup.data = dataArg.secretGroup.data;
-            const secretGroup = new SecretGroup();
+        await secretGroup.save();
-            secretGroup.id = plugins.smartunique.shortId(8);
+        return {
-            secretGroup.data = secretGroupObject.data;
+          resultSecretGroup: await secretGroup.createSavableObject(),
-            await secretGroup.save();
+        };
-          }
+      }),
-          return {
+    );
-            ok: true,
+
-          };
+    this.typedrouter.addTypedHandler<plugins.servezoneInterfaces.requests.secretgroup.IReq_UpdateSecretGroup>(
-        },
+      new plugins.typedrequest.TypedHandler('updateSecretGroup', async (dataArg) => {
-      ),
+        const secretGroup = await SecretGroup.getInstance({
+          id: dataArg.secretGroup.id,
+        });
+        secretGroup.data = dataArg.secretGroup.data;
+        await secretGroup.save();
+        return {
+          resultSecretGroup: await secretGroup.createSavableObject(),
+        };
+      }),
+    );
+
+    this.typedrouter.addTypedHandler<plugins.servezoneInterfaces.requests.secretgroup.IReq_DeleteSecretGroupById>(
+      new plugins.typedrequest.TypedHandler('deleteSecretGroupById', async (dataArg) => {
+        const secretGroup = await SecretGroup.getInstance({
+          id: dataArg.secretGroupId,
+        });
+        await secretGroup.delete();
+        return {
+          ok: true,
+        };
+      }),
     );
 
     this.typedrouter.addTypedHandler(
-      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.secret.IReq_Admin_DeleteConfigBundlesAndSecretGroups>(
+      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.secretbundle.IReq_GetEnvBundle>(
-        'adminDeleteConfigBundlesAndSecretGroups',
-        async (dataArg) => {
-          for (const secretGroupId of dataArg.secretGroupIds) {
-            const secretGroup = await SecretGroup.getInstance({
-              id: secretGroupId,
-            });
-            await secretGroup.delete();
-          }
-          for (const secretBundleId of dataArg.secretBundleIds) {
-            const configBundle = await SecretBundle.getInstance({
-              id: secretBundleId,
-            });
-            await configBundle.delete();
-            console.log(`deleted configbundle ${secretBundleId}`);
-          }
-          return {
-            ok: true,
-          };
-        },
-      ),
-    );
-
-    // lets add typedrouter routes for accessing the configvailt from apps
-    this.typedrouter.addTypedHandler(
-      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.secret.IReq_GetEnvBundle>(
         'getEnvBundle',
         async (dataArg) => {
           const wantedBundle = await SecretBundle.getInstance({

ts/manager.service/classes.servicemanager.ts

@@ -14,5 +14,26 @@ export class ServiceManager {
 
   constructor(cloudlyRef: Cloudly) {
     this.cloudlyRef = cloudlyRef;
+
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<plugins.servezoneInterfaces.requests.service.IRequest_Any_Cloudly_GetServices>(
+        'getServices',
+        async (reqArg) => {
+          await plugins.smartguard.passGuardsOrReject(reqArg, [
+            this.cloudlyRef.authManager.validIdentityGuard,
+          ]);
+
+          const services = await this.CService.getInstances({});
+
+          return {
+            services: await Promise.all(
+              services.map((service) => {
+                return service.createSavableObject();
+              })
+            ),
+          };
+        }
+      )
+    );
   }
 }

ts_apiclient/classes.cloudlyapiclient.ts

@@ -3,6 +3,10 @@ import * as plugins from './plugins.js';
 export type TClientType = 'api' | 'ci' | 'coreflow' | 'cli' | 'serverconfig';
 
 import { Image } from './classes.image.js';
+import { Service } from './classes.service.js';
+import { Cluster } from './classes.cluster.js';
+import { SecretBundle } from './classes.secretbundle.js';
+import { SecretGroup } from './classes.secretgroup.js';
 
 export class CloudlyApiClient {
   private cloudlyUrl: string;
@@ -20,7 +24,7 @@ export class CloudlyApiClient {
     plugins.servezoneInterfaces.requests.server.IRequest_TriggerServerAction['request']
   >();
 
-  constructor(optionsArg?: {
+  constructor(optionsArg: {
     registerAs: TClientType;
     cloudlyUrl?: string;
   }) {
@@ -155,8 +159,11 @@ export class CloudlyApiClient {
     return typedResponse.certificate;
   }
 
-  public images = {
+  public image = {
     // Images
+    getImageById: async (imageIdArg: string) => {
+      return Image.getImageById(this, imageIdArg);
+    },
     getImages: async () => {
       return Image.getImages(this);
     },
@@ -164,4 +171,56 @@ export class CloudlyApiClient {
       return Image.createImage(this, optionsArg);
     }
   }
+
+  public services = {
+    // Services
+    getServiceById: async (serviceIdArg: string) => {
+      return Service.getServiceById(this, serviceIdArg);
+    },
+    getServices: async () => {
+      return Service.getServices(this);
+    },
+    createService: async (optionsArg: Parameters<typeof Service.createService>[1]) => {
+      return Service.createService(this, optionsArg);
+    }
+  }
+
+  public cluster = {
+    // Clusters
+    getClusterById: async (clusterIdArg: string) => {
+      return Cluster.getClusterById(this, clusterIdArg);
+    },
+    getClusters: async () => {
+      return Cluster.getClusters(this);
+    },
+    createCluster: async (optionsArg: Parameters<typeof Cluster.createCluster>[1]) => {
+      return Cluster.createCluster(this, optionsArg);
+    }
+  }
+
+  public secretbundle = {
+    // SecretBundles
+    getSecretBundleById: async (secretBundleIdArg: string) => {
+      return SecretBundle.getSecretBundleById(this, secretBundleIdArg);
+    },
+    getSecretBundles: async () => {
+      return SecretBundle.getSecretBundles(this);
+    },
+    createSecretBundle: async (optionsArg: Parameters<typeof SecretBundle.createSecretBundle>[1]) => {
+      return SecretBundle.createSecretBundle(this, optionsArg);
+    }
+  }
+
+  public secretgroup = {
+    // SecretGroups
+    getSecretGroupById: async (secretGroupIdArg: string) => {
+      return SecretGroup.getSecretGroupById(this, secretGroupIdArg);
+    },
+    getSecretGroups: async () => {
+      return SecretGroup.getSecretGroups(this);
+    },
+    createSecretGroup: async (optionsArg: Parameters<typeof SecretGroup.createSecretGroup>[1]) => {
+      return SecretGroup.createSecretGroup(this, optionsArg);
+    }
+  }
 }

ts_apiclient/classes.cluster.ts

@@ -1,6 +1,84 @@
+import { CloudlyApiClient } from './classes.cloudlyapiclient.js';
 import * as plugins from './plugins.js';
 
-export class Cluster {
+export class Cluster implements plugins.servezoneInterfaces.data.ICluster {
-  public getServers() {}
+  // STATIC
+  public static async getClusterById(cloudlyClientRef: CloudlyApiClient, clusterIdArg: string) {
+    const getClusterByIdTR = cloudlyClientRef.typedsocketClient.createTypedRequest<plugins.servezoneInterfaces.requests.cluster.IReq_Any_Cloudly_GetClusterById>(
+      'getClusterById'
+    );
+    const response = await getClusterByIdTR.fire({
+      identity: cloudlyClientRef.identity,
+      clusterId: clusterIdArg,
+    });
+    const newCluster = new Cluster(cloudlyClientRef);
+    Object.assign(newCluster, response.cluster);
+    return newCluster;
+  }
 
+  public static async getClusters(cloudlyClientRef: CloudlyApiClient) {
+    const getClustersTR = cloudlyClientRef.typedsocketClient.createTypedRequest<plugins.servezoneInterfaces.requests.cluster.IReq_Any_Cloudly_GetClusters>(
+      'getClusters'
+    );
+    const response = await getClustersTR.fire({
+      identity: cloudlyClientRef.identity,
+    });
+    const clusterConfigs: Cluster[] = [];
+    for (const clusterConfig of response.clusters) {
+      const newCluster = new Cluster(cloudlyClientRef);
+      Object.assign(newCluster, clusterConfig);
+      clusterConfigs.push(newCluster);
+    }
+    return clusterConfigs;
+  }
+
+  public static async createCluster(cloudlyClientRef: CloudlyApiClient, clusterNameArg: string) {
+    const createClusterTR = cloudlyClientRef.typedsocketClient.createTypedRequest<plugins.servezoneInterfaces.requests.cluster.IRequest_CreateCluster>(
+      'createCluster'
+    );
+    const response = await createClusterTR.fire({
+      identity: cloudlyClientRef.identity,
+      clusterName: clusterNameArg,
+    });
+    const newCluster = new Cluster(cloudlyClientRef);
+    Object.assign(newCluster, response.cluster);
+    return newCluster;
+  }
+
+  // INSTANCE
+  public id: string;
+  public data: plugins.servezoneInterfaces.data.ICluster['data'];
+  public cloudlyClientRef: CloudlyApiClient;
+
+  constructor(cloudlyClientRef: CloudlyApiClient) {
+    this.cloudlyClientRef = cloudlyClientRef;
+  }
+
+
+  public async update() {
+    const updateClusterTR = this.cloudlyClientRef.typedsocketClient.createTypedRequest<plugins.servezoneInterfaces.requests.cluster.IReq_Any_Cloudly_UpdateCluster>(
+      'updateCluster'
+    );
+    const response = await updateClusterTR.fire({
+      identity: this.cloudlyClientRef.identity,
+      clusterData: this.data,
+    });
+
+    const resultClusterData = response.resultCluster.data;
+    plugins.smartexpect.expect(resultClusterData).toEqual(this.data);
+
+    return this;
+  }
+
+  public async delete(cloudlyClientRef: CloudlyApiClient, clusterIdArg: string) {
+    const deleteClusterTR = cloudlyClientRef.typedsocketClient.createTypedRequest<plugins.servezoneInterfaces.requests.cluster.IReq_Any_Cloudly_DeleteClusterById>(
+      'deleteClusterById'
+    );
+    const response = await deleteClusterTR.fire({
+      identity: cloudlyClientRef.identity,
+      clusterId: this.id,
+    });
+    plugins.smartexpect.expect(response.ok).toBeTrue();
+    return null;
+  }
 }

ts_apiclient/classes.image.ts

@@ -18,6 +18,19 @@ export class Image implements plugins.servezoneInterfaces.data.IImage {
     return resultImages;
   }
 
+  public static async getImageById(cloudlyClientRef: CloudlyApiClient, imageIdArg: string) {
+    const getImageByIdTR = cloudlyClientRef.typedsocketClient.createTypedRequest<plugins.servezoneInterfaces.requests.image.IRequest_GetImage>(
+      'getImage'
+    );
+    const response = await getImageByIdTR.fire({
+      identity: cloudlyClientRef.identity,
+      imageId: imageIdArg,
+    });
+    const newImage = new Image(cloudlyClientRef);
+    Object.assign(newImage, response.image);
+    return newImage;
+  }
+
   /**
    * creates a new image 
    */

ts_apiclient/classes.secretbundle.ts

@@ -0,0 +1,102 @@
+import * as plugins from './plugins.js';
+import type { CloudlyApiClient } from './classes.cloudlyapiclient.js';
+
+export class SecretBundle implements plugins.servezoneInterfaces.data.ISecretBundle {
+  public cloudlyClientRef: CloudlyApiClient;
+  
+  public id: string;
+  public data: plugins.servezoneInterfaces.data.ISecretBundle['data'];
+
+  constructor(cloudlyClientRef: CloudlyApiClient) {
+    this.cloudlyClientRef = cloudlyClientRef;
+  }
+
+  public static async getSecretBundleById(cloudlyClientRef: CloudlyApiClient, secretBundleIdArg: string) {
+    const getSecretBundleByIdTR = cloudlyClientRef.typedsocketClient.createTypedRequest<plugins.servezoneInterfaces.requests.secretbundle.IReq_GetSecretBundleById>(
+      'getSecretBundleById'
+    );
+    const response = await getSecretBundleByIdTR.fire({
+      identity: cloudlyClientRef.identity,
+      secretBundleId: secretBundleIdArg,
+    });
+    const newSecretBundle = new SecretBundle(cloudlyClientRef);
+    Object.assign(newSecretBundle, response.secretBundle);
+    return newSecretBundle;
+  }
+
+  public static async getSecretBundles(cloudlyClientRef: CloudlyApiClient) {
+    const getSecretBundlesTR = cloudlyClientRef.typedsocketClient.createTypedRequest<plugins.servezoneInterfaces.requests.secretbundle.IReq_GetSecretBundles>(
+      'getSecretBundles'
+    );
+    const response = await getSecretBundlesTR.fire({
+      identity: cloudlyClientRef.identity,
+    });
+    const secretBundles: SecretBundle[] = [];
+    for (const secretBundle of response.secretBundles) {
+      const newSecretBundle = new SecretBundle(cloudlyClientRef);
+      Object.assign(newSecretBundle, secretBundle);
+      secretBundles.push(newSecretBundle);
+    }
+    return secretBundles;
+  }
+
+  public static async createSecretBundle(cloudlyClientRef: CloudlyApiClient, secretBundleDataArg: Partial<plugins.servezoneInterfaces.data.ISecretBundle['data']>) {
+    const createSecretBundleTR = cloudlyClientRef.typedsocketClient.createTypedRequest<plugins.servezoneInterfaces.requests.secretbundle.IReq_CreateSecretBundle>(
+      'createSecretBundle'
+    );
+    const response = await createSecretBundleTR.fire({
+      identity: cloudlyClientRef.identity,
+      secretBundle: {
+        id: null,
+        data: {
+          name: secretBundleDataArg.name,
+          description: secretBundleDataArg.description,
+          type: secretBundleDataArg.type,
+          authorizations: secretBundleDataArg.authorizations,
+          includedImages: secretBundleDataArg.includedImages,
+          includedSecretGroupIds: secretBundleDataArg.includedSecretGroupIds,
+          includedTags: secretBundleDataArg.includedTags,
+        },
+      },
+    });
+    const newSecretBundle = new SecretBundle(cloudlyClientRef);
+    Object.assign(newSecretBundle, response.resultSecretBundle);
+    return newSecretBundle;
+  }
+
+  public async update() {
+    const updateSecretBundleTR = this.cloudlyClientRef.typedsocketClient.createTypedRequest<plugins.servezoneInterfaces.requests.secretbundle.IReq_UpdateSecretBundle>(
+      'updateSecretBundle'
+    );
+    const response = await updateSecretBundleTR.fire({
+      identity: this.cloudlyClientRef.identity,
+      secretBundle: {
+        id: this.id,
+        data: this.data,
+      },
+    });
+
+    const resultSecretBundleData = response.resultSecretBundle.data;
+    plugins.smartexpect.expect(resultSecretBundleData).toEqual(this.data);
+
+    return this;
+  }
+
+  public async delete(cloudlyClientRef: CloudlyApiClient, secretBundleIdArg: string) {
+    const deleteSecretBundleTR = cloudlyClientRef.typedsocketClient.createTypedRequest<plugins.servezoneInterfaces.requests.secretbundle.IReq_DeleteSecretBundleById>(
+      'deleteSecretBundleById'
+    );
+    const response = await deleteSecretBundleTR.fire({
+      identity: cloudlyClientRef.identity,
+      secretBundleId: this.id,
+    });
+    plugins.smartexpect.expect(response.ok).toBeTrue();
+    return null;
+  }
+
+  public async toFlatKeyValueObject() {
+    return {
+      // TODO: implement
+    };
+  }
+}

ts_apiclient/classes.secretgroup.ts

@@ -0,0 +1,96 @@
+import * as plugins from './plugins.js';
+import type { CloudlyApiClient } from './classes.cloudlyapiclient.js';
+
+export class SecretGroup implements plugins.servezoneInterfaces.data.ISecretGroup {
+  public cloudlyClientRef: CloudlyApiClient;
+  
+  public id: string;
+  public data: plugins.servezoneInterfaces.data.ISecretGroup['data'];
+
+  constructor(cloudlyClientRef: CloudlyApiClient) {
+    this.cloudlyClientRef = cloudlyClientRef;
+  }
+
+  public static async getSecretGroupById(cloudlyClientRef: CloudlyApiClient, secretGroupIdArg: string) {
+    const getSecretGroupByIdTR = cloudlyClientRef.typedsocketClient.createTypedRequest<plugins.servezoneInterfaces.requests.secretgroup.IReq_GetSecretGroupById>(
+      'getSecretGroupById'
+    );
+    const response = await getSecretGroupByIdTR.fire({
+      identity: cloudlyClientRef.identity,
+      secretGroupId: secretGroupIdArg,
+    });
+    const newSecretGroup = new SecretGroup(cloudlyClientRef);
+    Object.assign(newSecretGroup, response.secretGroup);
+    return newSecretGroup;
+  }
+
+  public static async getSecretGroups(cloudlyClientRef: CloudlyApiClient) {
+    const getSecretGroupsTR = cloudlyClientRef.typedsocketClient.createTypedRequest<plugins.servezoneInterfaces.requests.secretgroup.IReq_GetSecretGroups>(
+      'getSecretGroups'
+    );
+    const response = await getSecretGroupsTR.fire({
+      identity: cloudlyClientRef.identity,
+    });
+    const secretGroups: SecretGroup[] = [];
+    for (const secretGroup of response.secretGroups) {
+      const newSecretGroup = new SecretGroup(cloudlyClientRef);
+      Object.assign(newSecretGroup, secretGroup);
+      secretGroups.push(newSecretGroup);
+    }
+    return secretGroups;
+  }
+
+  public static async createSecretGroup(cloudlyClientRef: CloudlyApiClient, secretGroupDataArg: Partial<plugins.servezoneInterfaces.data.ISecretGroup['data']>) {
+    const createSecretGroupTR = cloudlyClientRef.typedsocketClient.createTypedRequest<plugins.servezoneInterfaces.requests.secretgroup.IReq_CreateSecretGroup>(
+      'createSecretGroup'
+    );
+    const response = await createSecretGroupTR.fire({
+      identity: cloudlyClientRef.identity,
+      secretGroup: {
+        id: null,
+        data: {
+          name: secretGroupDataArg.name,
+          description: secretGroupDataArg.description,
+          environments: secretGroupDataArg.environments,
+          key: secretGroupDataArg.key,
+          tags: secretGroupDataArg.tags,
+          priority: secretGroupDataArg.priority,
+        },
+      },
+    });
+    const newSecretGroup = new SecretGroup(cloudlyClientRef);
+    Object.assign(newSecretGroup, response.resultSecretGroup);    
+    return newSecretGroup;
+  }
+
+  // INSTANCE
+  public async update() {
+    const updateSecretGroupTR = this.cloudlyClientRef.typedsocketClient.createTypedRequest<plugins.servezoneInterfaces.requests.secretgroup.IReq_UpdateSecretGroup>(
+      'updateSecretGroup'
+    );
+    const response = await updateSecretGroupTR.fire({
+      identity: this.cloudlyClientRef.identity,
+      secretGroup: {
+        id: this.id,
+        data: this.data,
+      },
+    });
+
+    const resultSecretGroupData = response.resultSecretGroup.data;
+    plugins.smartexpect.expect(resultSecretGroupData).toEqual(this.data);
+
+    return this;
+  }
+
+  public async delete(cloudlyClientRef: CloudlyApiClient, secretGroupIdArg: string) {
+    const deleteSecretGroupTR = cloudlyClientRef.typedsocketClient.createTypedRequest<plugins.servezoneInterfaces.requests.secretgroup.IReq_DeleteSecretGroupById>(
+      'deleteSecretGroupById'
+    );
+    const response = await deleteSecretGroupTR.fire({
+      identity: cloudlyClientRef.identity,
+      secretGroupId: this.id,
+    });
+    plugins.smartexpect.expect(response.ok).toBeTrue();
+    return null;
+  }
+}

ts_apiclient/classes.service.ts

@@ -1,5 +1,80 @@
 import * as plugins from './plugins.js';
+import type { CloudlyApiClient } from './classes.cloudlyapiclient.js';
 
-export class Service {
+export class Service implements plugins.servezoneInterfaces.data.IService {
+  public static async getServices(cloudlyClientRef: CloudlyApiClient) {
+    const getAllServicesTR = cloudlyClientRef.typedsocketClient.createTypedRequest<plugins.servezoneInterfaces.requests.service.IRequest_Any_Cloudly_GetServices>(
+      'getServices'
+    );
+    const response = await getAllServicesTR.fire({
+      identity: cloudlyClientRef.identity,
+    });
+    const resultServices: Service[] = [];
+    for (const service of response.services) {
+      const newService = new Service(cloudlyClientRef);
+      Object.assign(newService, service);
+      resultServices.push(newService);
+    }
+    return resultServices;
+  }
 
+  public static async getServiceById(cloudlyClientRef: CloudlyApiClient, serviceIdArg: string) {
+    const getServiceByIdTR = cloudlyClientRef.typedsocketClient.createTypedRequest<plugins.servezoneInterfaces.requests.service.IRequest_Any_Cloudly_GetServiceById>(
+      'getServiceById'
+    );
+    const response = await getServiceByIdTR.fire({
+      identity: cloudlyClientRef.identity,
+      serviceId: serviceIdArg,
+    });
+    const newService = new Service(cloudlyClientRef);
+    Object.assign(newService, response.service);
+    return newService;
+  }
+
+  /**
+   * creates a new service 
+   */
+  public static async createService(cloudlyClientRef: CloudlyApiClient, serviceDataArg: Partial<plugins.servezoneInterfaces.data.IService['data']>) {
+    const createServiceTR = cloudlyClientRef.typedsocketClient.createTypedRequest<plugins.servezoneInterfaces.requests.service.IRequest_Any_Cloudly_CreateService>(
+      'createService'
+    );
+    const response = await createServiceTR.fire({
+      identity: cloudlyClientRef.identity,
+      name: serviceDataArg.name,
+      description: serviceDataArg.description,
+      imageId: serviceDataArg.imageId,
+      imageVersion: serviceDataArg.imageVersion,
+      environment: {},
+      secretBundleId: null,
+      scaleFactor: 1,
+      balancingStrategy: serviceDataArg.balancingStrategy,
+      ports: {
+        web: null,
+      },
+      resources: serviceDataArg.resources,
+      domains: [],
+    });
+    const newService = new Service(cloudlyClientRef);
+    Object.assign(newService, response.service);
+    return newService;
+  }
+
+  // INSTANCE
+  cloudlyClientRef: CloudlyApiClient;
+
+  public id: string;
+  public data: plugins.servezoneInterfaces.data.IService['data'];
+
+  constructor(cloudlyClientRef: CloudlyApiClient) {
+    this.cloudlyClientRef = cloudlyClientRef;
+  }
+
+  /**
+   * The service has a secret bundle.
+   * This function essentially returns the secret bundle as a flat object.
+   * In other words, it resolves secret groups and 
+   */
+  public async getSecretBundleAsFlatObject(environmentArg: string = 'production') {
+    
+  }
 }

ts_apiclient/plugins.ts

@@ -6,11 +6,13 @@ export {
 }
 
 // @push.rocks scope
+import * as smartexpect from '@push.rocks/smartexpect';
 import * as smartpromise from '@push.rocks/smartpromise';
 import * as smartrx from '@push.rocks/smartrx';
 import * as webstream from '@push.rocks/smartstream/web';
 
 export {
+  smartexpect,
   smartpromise,
   smartrx,
   webstream,

ts_interfaces/data/deployment.ts

@@ -1,12 +1,11 @@
 import * as plugins from '../plugins.js';
 
 /**
- * results from a DeploymentDirective
+ * a deployment happens when a service is deployed
  * tracks the status of a deployment
  */
 export interface IDeployment {
   id: string;
-  deploymentDirectiveId: string;
   affectedServiceIds: string[];
   usedImageId: string;
   deploymentLog: string[];

ts_interfaces/data/deploymentdirective.ts

@@ -1,14 +0,0 @@
-import type { IServiceRessources } from "./docker.js";
-
-/**
- * used for tellilng a cluster about a disired deployment
- * and specifies its configuration
- */
-export interface IDeploymentDirective {
-  id: string;
-  name: string;
-  imageClaim: string;
-  ports: { hostPort: number; containerPort: number }[];
-  environment: { [key: string]: string };
-  resources?: IServiceRessources;
-}

ts_interfaces/data/index.ts

@@ -2,7 +2,6 @@ export * from './cloudlyconfig.js';
 export * from './cluster.js';
 export * from './config.js';
 export * from './deployment.js';
-export * from './deploymentdirective.js';
 export * from './docker.js';
 export * from './env.js';
 export * from './event.js';

ts_interfaces/data/secretbundle.ts

@@ -7,6 +7,17 @@ export interface ISecretBundle {
     /**
      * determines if the secret is a service or an external secret
      * if external secret additional checks are put in place to protect the secret
+     * 
+     * * service:  
+     *   the bundle belongs to a service and can only be used by that service
+     * * npmci:  
+     *   the bundle is a secret bundle that is used by an npmci pipeline
+     *   production secrets will be omitted in any case
+     * * gitzone:  
+     *   the bundle is a secret bundle that is used by a gitzone.
+     *   Only local environment variables are allowed
+     * * external:  
+     *   the bundle is a secret bundle that is used by an external service
      */
     type: 'service' | 'npmci' | 'gitzone' | 'external';
 

ts_interfaces/data/service.ts

@@ -4,6 +4,7 @@ export interface IService {
   id: string;
   data: {
     name: string;
+    description: string;
     imageId: string;
     imageVersion: string;
     environment: { [key: string]: string };
@@ -21,6 +22,5 @@ export interface IService {
       protocol?: 'http' | 'https' | 'ssh';
     }[];
     deploymentIds: string[];
-    deploymentDirectiveIds: string[];
   };
 }

ts_interfaces/requests/admin.ts

@@ -0,0 +1,16 @@
+import * as plugins from '../plugins.js';
+import * as userInterfaces from '../data/user.js';
+
+export interface IReq_Admin_LoginWithUsernameAndPassword extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_Admin_LoginWithUsernameAndPassword
+> {
+  method: 'adminLoginWithUsernameAndPassword';
+  request: {
+    username: string;
+    password: string;
+  };
+  response: {
+    identity: userInterfaces.IIdentity;
+  }
+}

ts_interfaces/requests/cluster.ts

@@ -5,11 +5,11 @@ import * as plugins from '../plugins.js';
 /**
  * get all clusters
  */
-export interface IRequest_GetAllClusters extends plugins.typedrequestInterfaces.implementsTR<
+export interface IReq_Any_Cloudly_GetClusters extends plugins.typedrequestInterfaces.implementsTR<
   plugins.typedrequestInterfaces.ITypedRequest,
-  IRequest_GetAllClusters
+  IReq_Any_Cloudly_GetClusters
 > {
-  method: 'getAllClusters';
+  method: 'getClusters';
   request: {
     identity: userInterfaces.IIdentity;
   };
@@ -18,6 +18,21 @@ export interface IRequest_GetAllClusters extends plugins.typedrequestInterfaces.
   };
 }
 
+export interface IReq_Any_Cloudly_GetClusterById
+extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_Any_Cloudly_GetClusterById
+> {
+  method: 'getClusterById';
+  request: {
+    identity: userInterfaces.IIdentity;
+    clusterId: string;
+  };
+  response: {
+    cluster: clusterInterfaces.ICluster;
+  };
+}
+
 export interface IRequest_CreateCluster extends plugins.typedrequestInterfaces.implementsTR<
   plugins.typedrequestInterfaces.ITypedRequest,
   IRequest_CreateCluster
@@ -28,40 +43,40 @@ export interface IRequest_CreateCluster extends plugins.typedrequestInterfaces.i
     clusterName: string;
   };
   response: {
-    clusterConfig: clusterInterfaces.ICluster;
+    cluster: clusterInterfaces.ICluster;
   };
 }
 
 /**
  * updates a cluster
  */
-export interface IRequest_UpdateCluster extends plugins.typedrequestInterfaces.implementsTR<
+export interface IReq_Any_Cloudly_UpdateCluster extends plugins.typedrequestInterfaces.implementsTR<
   plugins.typedrequestInterfaces.ITypedRequest,
-  IRequest_UpdateCluster
+  IReq_Any_Cloudly_UpdateCluster
 > {
   method: 'updateCluster';
   request: {
     identity: userInterfaces.IIdentity;
-    clusterConfig: clusterInterfaces.ICluster;
+    clusterData: clusterInterfaces.ICluster['data'];
   };
   response: {
-    clusterConfig: clusterInterfaces.ICluster;
+    resultCluster: clusterInterfaces.ICluster;
   };
 }
 
 /**
  * deletes a cluster
  */
-export interface IRequest_DeleteCluster extends plugins.typedrequestInterfaces.implementsTR<
+export interface IReq_Any_Cloudly_DeleteClusterById extends plugins.typedrequestInterfaces.implementsTR<
   plugins.typedrequestInterfaces.ITypedRequest,
-  IRequest_DeleteCluster
+  IReq_Any_Cloudly_DeleteClusterById
 > {
-  method: 'deleteCluster';
+  method: 'deleteClusterById';
   request: {
     identity: userInterfaces.IIdentity;
     clusterId: string;
   };
   response: {
-    success: boolean;
+    ok: boolean;
   };
 }

ts_interfaces/requests/config.ts

@@ -3,7 +3,6 @@ import * as clusterInterfaces from '../data/cluster.js';
 import * as serverInterfaces from '../data/server.js';
 import * as userInterfaces from '../data/user.js';
 import type { IService } from '../data/service.js';
-import type { IDeploymentDirective } from '../data/deploymentdirective.js';
 
 export interface IRequest_Any_Cloudly_GetServerConfig
 extends plugins.typedrequestInterfaces.implementsTR<
@@ -31,7 +30,7 @@ extends plugins.typedrequestInterfaces.implementsTR<
   };
   response: {
     configData: clusterInterfaces.ICluster;
-    deploymentDirectives: IDeploymentDirective[];
+    services: IService[];
   };
 }
 
@@ -43,7 +42,7 @@ extends plugins.typedrequestInterfaces.implementsTR<
   method: 'pushClusterConfig';
   request: {
     configData: clusterInterfaces.ICluster;
-    deploymentDirectives: IDeploymentDirective[];
+    services: IService[];
   };
   response: {};
 }

ts_interfaces/requests/image.ts

@@ -18,6 +18,7 @@ export interface IRequest_GetAllImages extends plugins.typedrequestInterfaces.im
 
 /**
  * gets a single image
+ * authentication can happen via imageClaim or identity
  */
 export interface IRequest_GetImage extends plugins.typedrequestInterfaces.implementsTR<
   plugins.typedrequestInterfaces.ITypedRequest,

ts_interfaces/requests/index.ts

@@ -1,5 +1,6 @@
 import * as plugins from '../plugins.js';
 
+import * as adminRequests from './admin.js';
 import * as certificateRequests from './certificate.js';
 import * as clusterRequests from './cluster.js';
 import * as configRequests from './config.js';
@@ -9,12 +10,15 @@ import * as informRequests from './inform.js';
 import * as logRequests from './log.js';
 import * as networkRequests from './network.js';
 import * as routingRequests from './routing.js';
-import * as secretRequests from './secret.js';
+import * as secretBundleRequests from './secretbundle.js';
+import * as secretGroupRequests from './secretgroup.js'; 
 import * as serverRequests from './server.js';
+import * as serviceRequests from './service.js';
 import * as statusRequests from './status.js';
 import * as versionRequests from './version.js';
 
 export {
+  adminRequests as admin,
   certificateRequests as certificate,
   clusterRequests as cluster,
   configRequests as config,
@@ -24,8 +28,10 @@ export {
   logRequests as log,
   networkRequests as network,
   routingRequests as routing,
-  secretRequests as secret,
+  secretBundleRequests as secretbundle,
+  secretGroupRequests as secretgroup,
   serverRequests as server,
+  serviceRequests as service,
   statusRequests as status,
   versionRequests as version,
 };

ts_interfaces/requests/secret.ts

@@ -1,94 +0,0 @@
-import * as plugins from '../plugins.js';
-import * as data from '../data/index.js';
-import * as userInterfaces from '../data/user.js';
-
-export interface IReq_GetEnvBundle extends plugins.typedrequestInterfaces.implementsTR<
-  plugins.typedrequestInterfaces.ITypedRequest,
-  IReq_GetEnvBundle
-> {
-  method: 'getEnvBundle';
-  request: {
-    authorization: string;
-    /**
-     * specify this if you want to get a warning, if the envBundle is for an unexpected environment
-     */
-    environment?: string;
-  };
-  response: {
-    envBundle: data.IEnvBundle;
-  };
-}
-
-export interface IReq_Admin_LoginWithUsernameAndPassword extends plugins.typedrequestInterfaces.implementsTR<
-  plugins.typedrequestInterfaces.ITypedRequest,
-  IReq_Admin_LoginWithUsernameAndPassword
-> {
-  method: 'adminLoginWithUsernameAndPassword';
-  request: {
-    username: string;
-    password: string;
-  };
-  response: {
-    identity: userInterfaces.IIdentity;
-  }
-}
-
-export interface IReq_Admin_GetConfigBundlesAndSecretGroups extends plugins.typedrequestInterfaces.implementsTR<
-  plugins.typedrequestInterfaces.ITypedRequest,
-  IReq_Admin_GetConfigBundlesAndSecretGroups
-> {
-  method: 'adminGetConfigBundlesAndSecretGroups';
-  request: {
-    identity: userInterfaces.IIdentity;
-  };
-  response: {
-    secretBundles: data.ISecretBundle[];
-    secretGroups: data.ISecretGroup[];
-  };
-
-}
-
-export interface IReq_Admin_CreateConfigBundlesAndSecretGroups extends plugins.typedrequestInterfaces.implementsTR<
-  plugins.typedrequestInterfaces.ITypedRequest,
-  IReq_Admin_CreateConfigBundlesAndSecretGroups
-> {
-  method: 'adminCreateConfigBundlesAndSecretGroups';
-  request: {
-    identity: userInterfaces.IIdentity;
-    secretBundles: data.ISecretBundle[];
-    secretGroups: data.ISecretGroup[];
-  };
-  response: {
-    ok: boolean;
-  };
-}
-
-export interface IReq_Admin_UpdateConfigBundlesAndSecretGroups extends plugins.typedrequestInterfaces.implementsTR<
-  plugins.typedrequestInterfaces.ITypedRequest,
-  IReq_Admin_UpdateConfigBundlesAndSecretGroups
-> {
-  method: 'adminUpdateConfigBundlesAndSecretGroups';
-  request: {
-    identity: userInterfaces.IIdentity;
-    configBundles: data.ISecretBundle[];
-    secretGroups: data.ISecretGroup[];
-  };
-  response: {
-    ok: boolean;
-  };
-}
-
-export interface IReq_Admin_DeleteConfigBundlesAndSecretGroups extends plugins.typedrequestInterfaces.implementsTR<
-  plugins.typedrequestInterfaces.ITypedRequest,
-  IReq_Admin_DeleteConfigBundlesAndSecretGroups
-> {
-  method: 'adminDeleteConfigBundlesAndSecretGroups';
-  request: {
-    identity: userInterfaces.IIdentity;
-    secretBundleIds: string[];
-    secretGroupIds: string[];
-  };
-  response: {
-    ok: boolean;
-  };
-}

ts_interfaces/requests/secretbundle.ts

@@ -0,0 +1,94 @@
+import * as plugins from '../plugins.js';
+import * as data from '../data/index.js';
+import * as userInterfaces from '../data/user.js';
+
+/**
+ * when retrieving secrets for actual use, you do this in the form of an envBundle.
+ */
+export interface IReq_GetEnvBundle extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_GetEnvBundle
+> {
+  method: 'getEnvBundle';
+  request: {
+    authorization: string;
+    /**
+     * specify this if you want to get a warning, if the envBundle is for an unexpected environment
+     */
+    environment?: string;
+  };
+  response: {
+    envBundle: data.IEnvBundle;
+  };
+}
+
+export interface IReq_GetSecretBundles extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_GetSecretBundles
+> {
+  method: 'getSecretBundles';
+  request: {
+    identity: userInterfaces.IIdentity;
+  };
+  response: {
+    secretBundles: data.ISecretBundle[];
+  };
+
+}
+
+export interface IReq_GetSecretBundleById extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_GetSecretBundleById
+> {
+  method: 'getSecretBundleById';
+  request: {
+    identity: userInterfaces.IIdentity;
+    secretBundleId: string;
+  };
+  response: {
+    secretBundle: data.ISecretBundle;
+  };
+
+}
+
+export interface IReq_CreateSecretBundle extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_CreateSecretBundle
+> {
+  method: 'createSecretBundle';
+  request: {
+    identity: userInterfaces.IIdentity;
+    secretBundle: data.ISecretBundle;
+  };
+  response: {
+    resultSecretBundle: data.ISecretBundle;
+  };
+}
+
+export interface IReq_UpdateSecretBundle extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_UpdateSecretBundle
+> {
+  method: 'updateSecretBundle';
+  request: {
+    identity: userInterfaces.IIdentity;
+    secretBundle: data.ISecretBundle;
+  };
+  response: {
+    resultSecretBundle: data.ISecretBundle;
+  };
+}
+
+export interface IReq_DeleteSecretBundleById extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_DeleteSecretBundleById
+> {
+  method: 'deleteSecretBundleById';
+  request: {
+    identity: userInterfaces.IIdentity;
+    secretBundleId: string;
+  };
+  response: {
+    ok: boolean;
+  };
+}

ts_interfaces/requests/secretgroup.ts

@@ -0,0 +1,74 @@
+import * as plugins from '../plugins.js';
+import * as data from '../data/index.js';
+import * as userInterfaces from '../data/user.js';
+
+export interface IReq_GetSecretGroups extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_GetSecretGroups
+> {
+  method: 'getSecretGroups';
+  request: {
+    identity: userInterfaces.IIdentity;
+  };
+  response: {
+    secretGroups: data.ISecretGroup[];
+  };
+
+}
+
+export interface IReq_GetSecretGroupById extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_GetSecretGroupById
+> {
+  method: 'getSecretGroupById';
+  request: {
+    identity: userInterfaces.IIdentity;
+    secretGroupId: string;
+  };
+  response: {
+    secretGroup: data.ISecretGroup;
+  };
+
+}
+
+export interface IReq_CreateSecretGroup extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_CreateSecretGroup
+> {
+  method: 'createSecretGroup';
+  request: {
+    identity: userInterfaces.IIdentity;
+    secretGroup: data.ISecretGroup;
+  };
+  response: {
+    resultSecretGroup: data.ISecretGroup;
+  };
+}
+
+export interface IReq_UpdateSecretGroup extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_UpdateSecretGroup
+> {
+  method: 'updateSecretGroup';
+  request: {
+    identity: userInterfaces.IIdentity;
+    secretGroup: data.ISecretGroup;
+  };
+  response: {
+    resultSecretGroup: data.ISecretGroup;
+  };
+}
+
+export interface IReq_DeleteSecretGroupById extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_DeleteSecretGroupById
+> {
+  method: 'deleteSecretGroupById';
+  request: {
+    identity: userInterfaces.IIdentity;
+    secretGroupId: string;
+  };
+  response: {
+    ok: boolean;
+  };
+}

ts_interfaces/requests/service.ts

@@ -0,0 +1,113 @@
+import * as plugins from '../plugins.js';
+import type { IService } from '../data/service.js';
+import type { IIdentity } from '../data/user.js';
+import type { IServiceRessources } from '../data/docker.js';
+
+export interface IRequest_Any_Cloudly_GetServiceById 
+extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IRequest_Any_Cloudly_GetServiceById
+> {
+  method: 'getServiceById';
+  request: {
+    identity: IIdentity;
+    serviceId: string;
+  };
+  response: {
+    service: IService;
+  };
+}
+
+export interface IRequest_Any_Cloudly_GetServices
+extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IRequest_Any_Cloudly_GetServices
+> {
+  method: 'getServices';
+  request: {
+    identity: IIdentity;
+  };
+  response: {
+    services: IService[];
+  };
+}
+
+export interface IRequest_Any_Cloudly_CreateService
+extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IRequest_Any_Cloudly_CreateService
+> {
+  method: 'createService';
+  request: {
+    identity: IIdentity;
+    name: string;
+    description: string;
+    imageId: string;
+    imageVersion: string;
+    environment: { [key: string]: string };
+    secretBundleId: string;
+    scaleFactor: number;
+    balancingStrategy: 'round-robin' | 'least-connections';
+    ports: {
+      web: number;
+      custom?: { [domain: string]: string };
+    };
+    resources?: IServiceRessources;
+    domains: {
+      name: string;
+      port?: number;
+      protocol?: 'http' | 'https' | 'ssh';
+    }[];
+  };
+  response: {
+    service: IService;
+  };
+}
+
+export interface IRequest_Any_Cloudly_UpdateService
+extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IRequest_Any_Cloudly_UpdateService
+> {
+  method: 'updateService';
+  request: {
+    identity: IIdentity;
+    serviceId: string;
+    name: string;
+    description: string;
+    imageId: string;
+    imageVersion: string;
+    environment: { [key: string]: string };
+    secretBundleId: string;
+    scaleFactor: number;
+    balancingStrategy: 'round-robin' | 'least-connections';
+    ports: {
+      web: number;
+      custom?: { [domain: string]: string };
+    };
+    resources?: IServiceRessources;
+    domains: {
+      name: string;
+      port?: number;
+      protocol?: 'http' | 'https' | 'ssh';
+    }[];
+  };
+  response: {
+    service: IService;
+  };
+}
+
+export interface IRequest_Any_Cloudly_DeleteService
+extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IRequest_Any_Cloudly_DeleteService
+> {
+  method: 'deleteService';
+  request: {
+    identity: IIdentity;
+    serviceId: string;
+  };
+  response: {
+    success: boolean;
+  };
+}

ts_web/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/cloudly',
-  version: '4.3.1',
+  version: '4.7.0',
   description: 'A comprehensive tool for managing containerized applications across multiple cloud providers using Docker Swarmkit, featuring web, CLI, and API interfaces.'
 }

ts_web/appstate.ts

@@ -15,7 +15,7 @@ export const loginAction = loginStatePart.createAction<{ username: string; passw
   async (statePartArg, payloadArg) => {
     const currentState = statePartArg.getState();
     const trLogin =
-      new domtools.plugins.typedrequest.TypedRequest<plugins.interfaces.requests.secret.IReq_Admin_LoginWithUsernameAndPassword>(
+      new domtools.plugins.typedrequest.TypedRequest<plugins.interfaces.requests.admin.IReq_Admin_LoginWithUsernameAndPassword>(
         '/typedrequest',
         'adminLoginWithUsernameAndPassword'
       );
@@ -77,20 +77,34 @@ export const dataState = await appstate.getStatePart<IDataState>(
 );
 
 // Getting data
-export const getAllDataAction = dataState.createAction(async (statePartArg, partialArg?: 'secrets' | 'images') => {
+export const getAllDataAction = dataState.createAction(async (statePartArg) => {
   let currentState = statePartArg.getState();
-  // Secrets
+  // SecretsGroups
-  const trGetSecrets =
+  const trGetSecretGroups =
-    new domtools.plugins.typedrequest.TypedRequest<plugins.interfaces.requests.secret.IReq_Admin_GetConfigBundlesAndSecretGroups>(
+    new domtools.plugins.typedrequest.TypedRequest<plugins.interfaces.requests.secretgroup.IReq_GetSecretGroups>(
       '/typedrequest',
-      'adminGetConfigBundlesAndSecretGroups'
+      'getSecretGroups'
     );
-  const response = await trGetSecrets.fire({
+  const response = await trGetSecretGroups.fire({
     identity: loginStatePart.getState().identity,
   });
   currentState = {
     ...currentState,
-    ...response,
+    secretGroups: response.secretGroups,
+  };
+
+  // SecretBundles
+  const trGetSecretBundles =
+    new domtools.plugins.typedrequest.TypedRequest<plugins.interfaces.requests.secretbundle.IReq_GetSecretBundles>(
+      '/typedrequest',
+      'getSecretBundles'
+    );
+  const responseSecretBundles = await trGetSecretBundles.fire({
+    identity: loginStatePart.getState().identity,
+  });
+  currentState = {
+    ...currentState,
+    secretBundles: responseSecretBundles.secretBundles,
   };
 
   // images
@@ -104,14 +118,14 @@ export const getAllDataAction = dataState.createAction(async (statePartArg, part
   });
   currentState = {
     ...currentState,
-    ...responseImages,
+    images: responseImages.images,
   };
 
   // Clusters
   const trGetClusters =
-    new domtools.plugins.typedrequest.TypedRequest<plugins.interfaces.requests.cluster.IRequest_GetAllClusters>(
+    new domtools.plugins.typedrequest.TypedRequest<plugins.interfaces.requests.cluster.IReq_Any_Cloudly_GetClusters>(
       '/typedrequest',
-      'getAllClusters'
+      'getClusters'
     );
   const responseClusters = await trGetClusters.fire({
     identity: loginStatePart.getState().identity,
@@ -119,7 +133,7 @@ export const getAllDataAction = dataState.createAction(async (statePartArg, part
 
   currentState = {
     ...currentState,
-    ...responseClusters,
+    clusters: responseClusters.clusters,
   }
 
   return currentState;
@@ -130,14 +144,13 @@ export const createSecretGroupAction = dataState.createAction(
   async (statePartArg, payloadArg: plugins.interfaces.data.ISecretGroup) => {
     let currentState = statePartArg.getState();
     const trCreateSecretGroup =
-      new domtools.plugins.typedrequest.TypedRequest<plugins.interfaces.requests.secret.IReq_Admin_CreateConfigBundlesAndSecretGroups>(
+      new domtools.plugins.typedrequest.TypedRequest<plugins.interfaces.requests.secretgroup.IReq_CreateSecretGroup>(
         '/typedrequest',
-        'adminCreateConfigBundlesAndSecretGroups'
+        'createSecretGroup'
       );
     const response = await trCreateSecretGroup.fire({
       identity: loginStatePart.getState().identity,
-      secretBundles: [],
+      secretGroup: payloadArg,
-      secretGroups: [payloadArg],
     });
     currentState = await dataState.dispatchAction(getAllDataAction, null);
     return currentState;
@@ -149,14 +162,13 @@ export const deleteSecretGroupAction = dataState.createAction(
   async (statePartArg, payloadArg: { secretGroupId: string }) => {
     let currentState = statePartArg.getState();
     const trDeleteSecretGroup =
-      new domtools.plugins.typedrequest.TypedRequest<plugins.interfaces.requests.secret.IReq_Admin_DeleteConfigBundlesAndSecretGroups>(
+      new domtools.plugins.typedrequest.TypedRequest<plugins.interfaces.requests.secretgroup.IReq_DeleteSecretGroupById>(
         '/typedrequest',
-        'adminDeleteConfigBundlesAndSecretGroups'
+        'deleteSecretGroupById'
       );
     const response = await trDeleteSecretGroup.fire({
       identity: loginStatePart.getState().identity,
-      secretBundleIds: [],
+      secretGroupId: payloadArg.secretGroupId,
-      secretGroupIds: [payloadArg.secretGroupId],
     });
     currentState = await dataState.dispatchAction(getAllDataAction, null);
     return currentState;
@@ -168,14 +180,13 @@ export const deleteSecretBundleAction = dataState.createAction(
   async (statePartArg, payloadArg: { configBundleId: string }) => {
     let currentState = statePartArg.getState();
     const trDeleteConfigBundle =
-      new domtools.plugins.typedrequest.TypedRequest<plugins.interfaces.requests.secret.IReq_Admin_DeleteConfigBundlesAndSecretGroups>(
+      new domtools.plugins.typedrequest.TypedRequest<plugins.interfaces.requests.secretbundle.IReq_DeleteSecretBundleById>( 
         '/typedrequest',
-        'adminDeleteConfigBundlesAndSecretGroups'
+        'deleteSecretBundleById'
       );
     const response = await trDeleteConfigBundle.fire({
       identity: loginStatePart.getState().identity,
-      secretBundleIds: [payloadArg.configBundleId],
+      secretBundleId: payloadArg.configBundleId,
-      secretGroupIds: [],
     });
     currentState = await dataState.dispatchAction(getAllDataAction, null);
     return currentState;
@@ -249,7 +260,7 @@ export const addClusterAction = dataState.createAction(
     currentState = {
       ...currentState,
       ...{
-        clusters: [...currentState.clusters, response.clusterConfig],
+        clusters: [...currentState.clusters, response.cluster],
       },
     }
     return currentState;