Deploy website - based on 97efa4808a

.cargo/config.toml

@@ -1,5 +0,0 @@
-[alias]
-xtask = "run --package xtask --"
-
-[build]
-rustflags = ["-Wunused-crate-dependencies"]

.devcontainer/dev.compose.yaml

@@ -1,39 +0,0 @@
-services:
-  dev:
-    image: mcr.microsoft.com/devcontainers/rust:1-bookworm 
-    volumes:
-      # Mount the root folder that contains .git
-      - ../:/workspace:cached
-      - /var/run/docker.sock:/var/run/docker.sock
-      - /proc:/proc
-      - repos:/etc/komodo/repos
-      - stacks:/etc/komodo/stacks
-    command: sleep infinity
-    ports:
-      - "9120:9120"
-    environment:
-      KOMODO_HOST: http://localhost:9120
-      KOMODO_FIRST_SERVER: http://localhost:8120
-      KOMODO_DATABASE_ADDRESS: db
-      KOMODO_ENABLE_NEW_USERS: true
-      KOMODO_LOCAL_AUTH: true
-      KOMODO_JWT_SECRET: a_random_secret
-      VITE_KOMODO_HOST: http://localhost:9120
-      KOMODO_CORS_ALLOWED_ORIGINS: http://localhost:5173
-      KOMODO_CORS_ALLOW_CREDENTIALS: true
-      PERIPHERY_SSL_ENABLED: false
-      KOMODO_SESSION_ALLOW_CROSS_SITE: true
-    links:
-      - db
-    # ...
-
-  db:
-    extends:
-      file: ../dev.compose.yaml
-      service: ferretdb
-
-volumes:
-  data:
-  repo-cache:
-  repos:
-  stacks:

.devcontainer/devcontainer.json

@@ -1,52 +0,0 @@
-// For format details, see https://aka.ms/devcontainer.json. For config options, see the
-// README at: https://github.com/devcontainers/templates/tree/main/src/rust
-{
-	"name": "Komodo",
-	// Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
-	//"image": "mcr.microsoft.com/devcontainers/rust:1-1-bullseye",
-	"dockerComposeFile": ["dev.compose.yaml"],
-	"workspaceFolder": "/workspace",
-  	"service": "dev",
-	// Features to add to the dev container. More info: https://containers.dev/features.
-	"features": {
-		"ghcr.io/devcontainers/features/node:1": {
-			"version": "22.12.0" 
-		},
-		"ghcr.io/devcontainers-community/features/deno:1": {
-
-		}
-	},
-
-	// Use 'mounts' to make the cargo cache persistent in a Docker Volume.
-	"mounts": [
-		{
-			"source": "devcontainer-cargo-cache-${devcontainerId}",
-			"target": "/usr/local/cargo",
-			"type": "volume"
-		}
-	],
-
-	// Use 'forwardPorts' to make a list of ports inside the container available locally.
-	"forwardPorts": [
-		5173,
-		9120
-	],
-
-	// Use 'postCreateCommand' to run commands after the container is created.
-	"postCreateCommand": "./.devcontainer/postCreate.sh",
-
-	"runServices": [
-		"db"
-	],
-
-	// Configure tool-specific properties.
-	// "customizations": {},
-
-	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
-	// "remoteUser": "root"
-	
-	 "remoteEnv": {
-		// Avoid out of memory error when running `yarn build`
-		"NODE_OPTIONS": "--max-old-space-size=4096"
-	}
-}

.devcontainer/postCreate.sh

@@ -1,9 +0,0 @@
-#!/bin/sh
-
-cargo install typeshare-cli
-
-sudo mkdir -p /etc/komodo/keys
-sudo chown -R $(whoami) /etc/komodo
-
-sudo mkdir -p /config/keys
-sudo chown -R $(whoami) /config

.github/FUNDING.yml

@@ -1,2 +0,0 @@
-# https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/displaying-a-sponsor-button-in-your-repository
-open_collective: komodo

.github/workflows/ci.yml

@@ -1,56 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-    branches: [main]
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  build:
-    name: Build & Test
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install Rust
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          toolchain: stable
-
-      # - name: Cache cargo registry
-      #   uses: actions/cache@v4
-      #   with:
-      #     path: |
-      #       ~/.cargo/registry
-      #       ~/.cargo/git
-      #       target
-      #     key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
-      #     restore-keys: |
-      #       ${{ runner.os }}-cargo-
-
-      - name: Build
-        run: cargo build --verbose
-
-      - name: Run tests
-        run: cargo test --verbose
-
-  fmt:
-    name: Format
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install Rust
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          toolchain: stable
-          components: rustfmt
-
-      - name: Check formatting
-        run: cargo fmt --all -- --check

.gitignore

@@ -1,9 +0,0 @@
-target
-node_modules
-dist
-deno.lock
-.env
-.env.development
-.DS_Store
-.idea
-.dev

.kminclude

@@ -1 +0,0 @@
-.dev

.vscode/extensions.json

@@ -1,8 +0,0 @@
-{
-    "recommendations": [
-        "rust-lang.rust-analyzer",
-        "tamasfe.even-better-toml",
-        "vadimcn.vscode-lldb",
-        "denoland.vscode-deno"
-    ]
-}

.vscode/resolver.code-snippets

@@ -1,25 +0,0 @@
-{
-	"resolve": {
-		"scope": "rust",
-		"prefix": "resolve",
-		"body": [
-			"impl Resolve<${0}> for ${1} {",
-			"\tasync fn resolve(self, _: &${0}) -> Result<Self::Response, Self::Error> {",
-			"\t\ttodo!()",
-			"\t}",
-			"}"
-		]
-	},
-	"static": {
-		"scope": "rust",
-		"prefix": "static",
-		"body": [
-			"fn ${1}() -> &'static ${2} {",
-			"\tstatic ${0}: OnceLock<${2}> = OnceLock::new();",
-			"\t${0}.get_or_init(|| {",
-			"\t\ttodo!()",
-			"\t})",
-			"}"
-		]
-	}
-}

.vscode/tasks.json

@@ -1,179 +0,0 @@
-{
-    "version": "2.0.0",
-    "tasks": [
-        {
-            "label": "Run Core",
-            "command": "cargo",
-            "args": [
-                "run",
-                "-p",
-                "komodo_core",
-                "--release"
-            ],
-            "options": {
-                "cwd": "${workspaceFolder}",
-                "env": {
-                    "KOMODO_CONFIG_PATH": "test.core.config.toml"
-                }
-            },
-            "problemMatcher": [
-                "$rustc"
-            ]
-        },
-        {
-            "label": "Build Core",
-            "command": "cargo",
-            "args": [
-                "build",
-                "-p",
-                "komodo_core",
-                "--release"
-            ],
-            "options": {
-                "cwd": "${workspaceFolder}",
-                "env": {
-                    "KOMODO_CONFIG_PATH": "test.core.config.toml"
-                }
-            },
-            "problemMatcher": [
-                "$rustc"
-            ]
-        },
-        {
-            "label": "Run Periphery",
-            "command": "cargo",
-            "args": [
-                "run",
-                "-p",
-                "komodo_periphery",
-                "--release"
-            ],
-            "options": {
-                "cwd": "${workspaceFolder}",
-                "env": {
-                    "KOMODO_CONFIG_PATH": "test.periphery.config.toml"
-                }
-            },
-            "problemMatcher": [
-                "$rustc"
-            ]
-        },
-        {
-            "label": "Build Periphery",
-            "command": "cargo",
-            "args": [
-                "build",
-                "-p",
-                "komodo_periphery",
-                "--release"
-            ],
-            "options": {
-                "cwd": "${workspaceFolder}",
-                "env": {
-                    "KOMODO_CONFIG_PATH": "test.periphery.config.toml"
-                }
-            },
-            "problemMatcher": [
-                "$rustc"
-            ]
-        },
-        {
-            "label": "Run Backend",
-            "dependsOn": [
-                "Run Core",
-                "Run Periphery"
-            ],
-            "problemMatcher": [
-                "$rustc"
-            ]
-        },
-        {
-            "label": "Build TS Client Types",
-            "type": "process",
-            "command": "node",
-            "args": [
-                "./client/core/ts/generate_types.mjs"
-            ],
-            "problemMatcher": []
-        },
-        {
-            "label": "Init TS Client",
-            "type": "shell",
-            "command": "yarn && yarn build && yarn link",
-            "options": {
-                "cwd": "${workspaceFolder}/client/core/ts",
-            },
-            "problemMatcher": []
-        },
-        {
-            "label": "Init UI Client",
-            "type": "shell",
-            "command": "yarn link komodo_client && yarn install",
-            "options": {
-                "cwd": "${workspaceFolder}/ui",
-            },
-            "problemMatcher": []
-        },
-        {
-            "label": "Init UI",
-            "dependsOn": [
-                "Build TS Client Types",
-                "Init TS Client",
-                "Init UI Client"
-            ],
-            "dependsOrder": "sequence",
-            "problemMatcher": []
-        },
-        {
-            "label": "Build UI",
-            "type": "shell",
-            "command": "yarn build",
-            "options": {
-                "cwd": "${workspaceFolder}/ui",
-            },
-            "problemMatcher": []
-        },
-        {
-            "label": "Prepare UI For Run",
-            "type": "shell",
-            "command": "cp -r ./client/core/ts/dist/. ui/public/client/.",
-            "options": {
-                "cwd": "${workspaceFolder}",
-            },
-            "dependsOn": [
-                "Build TS Client Types",
-                "Build UI"
-            ],
-            "dependsOrder": "sequence",
-            "problemMatcher": []
-        },
-        {
-            "label": "Run UI",
-            "type": "shell",
-            "command": "yarn dev",
-            "options": {
-                "cwd": "${workspaceFolder}/ui",
-            },
-            "dependsOn": ["Prepare UI For Run"],
-            "problemMatcher": []
-        },
-        {
-            "label": "Init",
-            "dependsOn": [
-                "Build Backend",
-                "Init UI"
-            ],
-            "dependsOrder": "sequence",
-            "problemMatcher": []
-        },
-        {
-            "label": "Run Komodo",
-            "dependsOn": [
-                "Run Core",
-                "Run Periphery",
-                "Run UI"
-            ],
-            "problemMatcher": []
-        },
-    ]
-  }

Cargo.toml

@@ -1,142 +0,0 @@
-[workspace]
-resolver = "2"
-members = [
-	"bin/*",
-	"lib/*",
-	"xtask",
-	"client/core/rs",
-	"client/periphery/rs",
-]
-
-[workspace.package]
-version = "2.3.0"
-edition = "2024"
-license = "GPL-3.0-or-later"
-repository = "https://github.com/moghtech/komodo"
-homepage = "https://komo.do"
-
-[workspace.dependencies]
-# LOCAL
-komodo_client = { path = "client/core/rs" }
-periphery_client = { path = "client/periphery/rs" }
-environment = { path = "lib/environment" }
-interpolate = { path = "lib/interpolate" }
-formatting = { path = "lib/formatting" }
-transport = { path = "lib/transport" }
-database = { path = "lib/database" }
-encoding = { path = "lib/encoding" }
-command = { path = "lib/command" }
-git = { path = "lib/git" }
-
-# MOGH
-slack = { version = "2.0.0", package = "slack_client_rs", default-features = false, features = ["rustls"] }
-mogh_error = { version = "1.0.4", default-features = false }
-derive_default_builder = "0.1.8"
-async_timing_util = "1.1.0"
-mogh_auth_client = "1.7.0"
-mogh_auth_server = "1.7.0"
-mogh_secret_file = "1.0.1"
-mogh_validations = "1.0.1"
-mogh_rate_limit = "1.0.1"
-partial_derive2 = "0.5.0"
-mongo_indexed = "2.1.0"
-mogh_resolver = "1.0.0"
-mogh_config = "1.1.0"
-mogh_logger = "1.3.4"
-mogh_server = "1.5.0"
-toml_pretty = "2.0.0"
-mogh_cache = "1.1.2"
-mogh_pki = "1.1.3"
-mungos = "3.7.0"
-svi = "1.2.0"
-
-# ASYNC
-reqwest = { version = "0.13.4", default-features = false, features = ["json", "stream", "form", "query", "rustls"] }
-tokio = { version = "1.53.1", features = ["full"] }
-tokio-util = { version = "0.7.19", features = ["io", "codec"] }
-tokio-stream = { version = "0.1.19", features = ["sync"] }
-pin-project-lite = "0.2.17"
-futures-util = "0.3.33"
-arc-swap = "1.9.2"
-
-# SERVER
-tokio-tungstenite = { version = "0.30.0", features = ["rustls-tls-native-roots"] }
-axum = { version = "0.8.9", features = ["ws", "json", "macros"] }
-axum-extra = { version = "0.12.6", features = ["typed-header"] }
-
-# OPENAPI
-utoipa-scalar = { version = "0.3.0", features = ["axum"] }
-utoipa = "5.5.0"
-
-# SER/DE
-ipnetwork = { version = "0.21.1", features = ["serde"] }
-indexmap = { version = "2.14.0", features = ["serde"] }
-serde = { version = "1.0.229", features = ["derive"] }
-strum = { version = "0.28.0", features = ["derive"] }
-bson = { version = "2.15.0" } # must keep in sync with mongodb version
-toml = "1.1.3"
-serde_yaml_ng = "0.10.0"
-serde_json = "1.0.151"
-serde_qs = "1.1.2"
-url = "2.5.8"
-
-# ERROR
-anyhow = "1.0.104"
-thiserror = "2.0.19"
-
-# SYSTEM
-libc = "0.2.189"
-
-# LOGGING
-tracing = "0.1.44"
-
-# CONFIG
-clap = { version = "4.6.4", features = ["derive"] }
-dotenvy = "0.15.7"
-envy = "0.4.2"
-
-# CRYPTO / AUTH
-uuid = { version = "1.24.0", features = ["v4", "fast-rng", "serde"] }
-rustls = { version = "0.23.42", features = ["aws-lc-rs"] }
-data-encoding = "2.11.0"
-urlencoding = "2.1.3"
-bcrypt = "0.19.2"
-hmac = "0.13.0"
-sha1 = "0.11.0"
-sha2 = "0.11.0"
-rand = "0.10.2"
-hex = "0.4.3"
-
-# SYSTEM
-hickory-resolver = "0.26.1"
-portable-pty = "0.9.0"
-shell-escape = "0.1.5"
-crossterm = "0.29.0"
-bollard = "0.21.0"
-sysinfo = "0.39.6"
-shlex = "2.0.1"
-
-# CLOUD
-aws-config = "1.10.0"
-aws-sdk-ec2 = "1.241.0"
-aws-credential-types = "1.3.0"
-
-## CRON
-english-to-cron = "0.1.7"
-chrono-tz = "0.10.4"
-chrono = "0.4.45"
-croner = "3.0.1"
-
-# MISC
-async-compression = { version = "0.4.42", features = ["tokio", "gzip"] }
-schemars = { version = "1.2.1", features = ["indexmap2"] }
-derive_builder = "0.20.2"
-comfy-table = "7.2.2"
-typeshare = "1.0.5"
-wildcard = "0.3.0"
-colored = "3.1.1"
-bytes = "1.12.1"
-regex = "1.13.1"
-
-[profile.release]
-strip = "debuginfo"

LICENSE

@@ -1,674 +0,0 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<https://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.

action/build.ts

@@ -1,2 +0,0 @@
-import { run } from "./run.ts";
-await run("build-komodo");

action/deno.json

@@ -1,5 +0,0 @@
-{
-  "imports": {
-    "@std/toml": "jsr:@std/toml"
-  }
-}

action/deploy-ui.ts

@@ -1,4 +0,0 @@
-const cmd = "km run -y action deploy-komodo-ui-change";
-new Deno.Command("bash", {
-  args: ["-c", cmd],
-}).spawn();

action/deploy.ts

@@ -1,2 +0,0 @@
-import { run } from "./run.ts";
-await run("deploy-komodo");

action/run.ts

@@ -1,52 +0,0 @@
-import * as TOML from "@std/toml";
-
-export const run = async (action: string) => {
-  const branch = await new Deno.Command("bash", {
-    args: ["-c", "git rev-parse --abbrev-ref HEAD"],
-  })
-    .output()
-    .then((r) => new TextDecoder("utf-8").decode(r.stdout).trim());
-
-  const cargo_toml_str = await Deno.readTextFile("Cargo.toml");
-  const prev_version = (
-    TOML.parse(cargo_toml_str) as {
-      workspace: { package: { version: string } };
-    }
-  ).workspace.package.version;
-
-  const [version, tag, count] = prev_version.split("-");
-  const next_count = Number(count) + 1;
-
-  const next_version = `${version}-${tag}-${next_count}`;
-
-  await Deno.writeTextFile(
-    "Cargo.toml",
-    cargo_toml_str.replace(
-      `version = "${prev_version}"`,
-      `version = "${next_version}"`
-    )
-  );
-
-  // Cargo check first here to make sure lock file is updated before commit.
-  const cmd = `
-cargo check
-echo ""
-
-git add --all
-git commit --all --message "deploy ${version}-${tag}-${next_count}"
-
-echo ""
-git push
-echo ""
-
-km run -y action ${action} "KOMODO_BRANCH=${branch}&KOMODO_VERSION=${version}&KOMODO_TAG=${tag}-${next_count}"
-`
-    .split("\n")
-    .map((line) => line.trim())
-    .filter((line) => line.length > 0 && !line.startsWith("//"))
-    .join(" && ");
-
-  new Deno.Command("bash", {
-    args: ["-c", cmd],
-  }).spawn();
-};

assets/js/138e0e15.cd653e4a.js

@@ -0,0 +1 @@
+"use strict";(self.webpackChunkdocsite=self.webpackChunkdocsite||[]).push([[921],{1597:s=>{s.exports=JSON.parse('{"name":"@easyops-cn/docusaurus-search-local","id":"default"}')}}]);

assets/js/1df93b7f.ee914b6f.js.LICENSE.txt

@@ -0,0 +1,6 @@
+/**
+ * @license lucide-react v0.577.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */

assets/js/237.81a2e61a.js

@@ -0,0 +1 @@
+"use strict";(self.webpackChunkdocsite=self.webpackChunkdocsite||[]).push([[237],{2237:(e,t,i)=>{i.r(t),i.d(t,{default:()=>d});i(6540);var n=i(1312),o=i(5500),s=i(1293),r=i(3363),a=i(4848);function d(){const e=(0,n.T)({id:"theme.NotFound.title",message:"Page Not Found"});return(0,a.jsxs)(a.Fragment,{children:[(0,a.jsx)(o.be,{title:e}),(0,a.jsx)(s.A,{children:(0,a.jsx)(r.A,{})})]})}},3363:(e,t,i)=>{i.d(t,{A:()=>a});i(6540);var n=i(4164),o=i(1312),s=i(1107),r=i(4848);function a({className:e}){return(0,r.jsx)("main",{className:(0,n.A)("container margin-vert--xl",e),children:(0,r.jsx)("div",{className:"row",children:(0,r.jsxs)("div",{className:"col col--6 col--offset-3",children:[(0,r.jsx)(s.A,{as:"h1",className:"hero__title",children:(0,r.jsx)(o.A,{id:"theme.NotFound.title",description:"The title of the 404 page",children:"Page Not Found"})}),(0,r.jsx)("p",{children:(0,r.jsx)(o.A,{id:"theme.NotFound.p1",description:"The first paragraph of the 404 page",children:"We could not find what you were looking for."})}),(0,r.jsx)("p",{children:(0,r.jsx)(o.A,{id:"theme.NotFound.p2",description:"The 2nd paragraph of the 404 page",children:"Please contact the owner of the site that linked you to the original URL and let them know their link is broken."})})]})})})}}}]);

assets/js/489.35969693.js.LICENSE.txt

@@ -0,0 +1 @@
+/*! https://mths.be/cssesc v3.0.0 by @mathias */

assets/js/540.d8cc415a.js.LICENSE.txt

@@ -0,0 +1,67 @@
+/*!
+ * lunr.Builder
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/*!
+ * lunr.Index
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/*!
+ * lunr.Pipeline
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/*!
+ * lunr.Set
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/*!
+ * lunr.TokenSet
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/*!
+ * lunr.Vector
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/*!
+ * lunr.stemmer
+ * Copyright (C) 2020 Oliver Nightingale
+ * Includes code from - http://tartarus.org/~martin/PorterStemmer/js.txt
+ */
+
+/*!
+ * lunr.stopWordFilter
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/*!
+ * lunr.tokenizer
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/*!
+ * lunr.trimmer
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/*!
+ * lunr.utils
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * lunr - http://lunrjs.com - A bit like Solr, but much smaller and not as bright - 2.3.9
+ * Copyright (C) 2020 Oliver Nightingale
+ * @license MIT
+ */

assets/js/5e95c892.3354df32.js

@@ -0,0 +1 @@
+"use strict";(self.webpackChunkdocsite=self.webpackChunkdocsite||[]).push([[647],{7121:(e,s,r)=>{r.r(s),r.d(s,{default:()=>i});r(6540);var c=r(4164),t=r(7559),u=r(5500),a=r(2831),d=r(1293),n=r(4848);function i(e){return(0,n.jsx)(u.e3,{className:(0,c.A)(t.G.wrapper.docsPages),children:(0,n.jsx)(d.A,{children:(0,a.v)(e.route.routes)})})}}}]);

assets/js/741.4dd25b36.js

@@ -0,0 +1 @@
+(self.webpackChunkdocsite=self.webpackChunkdocsite||[]).push([[741],{5741:()=>{}}]);

assets/js/790a1910.e617f9f2.js

@@ -0,0 +1 @@
+"use strict";(self.webpackChunkdocsite=self.webpackChunkdocsite||[]).push([[339],{4191:(e,t,n)=>{n.r(t),n.d(t,{assets:()=>r,contentTitle:()=>a,default:()=>p,frontMatter:()=>i,metadata:()=>s,toc:()=>d});const s=JSON.parse('{"id":"ecosystem/api","title":"API and Clients","description":"Komodo Core exposes an RPC-like HTTP API to read data, write configuration, and execute actions.","source":"@site/docs/ecosystem/api.md","sourceDirName":"ecosystem","slug":"/ecosystem/api","permalink":"/docs/ecosystem/api","draft":false,"unlisted":false,"editUrl":"https://github.com/moghtech/komodo/tree/main/docsite/docs/ecosystem/api.md","tags":[],"version":"current","frontMatter":{},"sidebar":"docs","previous":{"title":"Komodo CLI","permalink":"/docs/ecosystem/cli"},"next":{"title":"Community","permalink":"/docs/ecosystem/community"}}');var o=n(4848),c=n(8453);const i={},a="API and Clients",r={},d=[{value:"Rust Client",id:"rust-client",level:2},{value:"Typescript Client",id:"typescript-client",level:2}];function l(e){const t={a:"a",code:"code",h1:"h1",h2:"h2",header:"header",p:"p",pre:"pre",strong:"strong",...(0,c.R)(),...e.components};return(0,o.jsxs)(o.Fragment,{children:[(0,o.jsx)(t.header,{children:(0,o.jsx)(t.h1,{id:"api-and-clients",children:"API and Clients"})}),"\n",(0,o.jsxs)(t.p,{children:["Komodo Core exposes an RPC-like HTTP API to read data, write configuration, and execute actions.\nThere are typesafe clients available in\n",(0,o.jsx)(t.a,{href:"/docs/ecosystem/api#rust-client",children:(0,o.jsx)(t.strong,{children:"Rust"})})," and ",(0,o.jsx)(t.a,{href:"/docs/ecosystem/api#typescript-client",children:(0,o.jsx)(t.strong,{children:"Typescript"})}),"."]}),"\n",(0,o.jsxs)(t.p,{children:["The full API documentation is ",(0,o.jsx)(t.a,{href:"https://docs.rs/komodo_client/latest/komodo_client/api/index.html",children:(0,o.jsx)(t.strong,{children:"available here"})}),"."]}),"\n",(0,o.jsx)(t.h2,{id:"rust-client",children:"Rust Client"}),"\n",(0,o.jsxs)(t.p,{children:["The Rust client is published to crates.io at ",(0,o.jsx)(t.a,{href:"https://crates.io/crates/komodo_client",children:"komodo_client"}),"."]}),"\n",(0,o.jsx)(t.pre,{children:(0,o.jsx)(t.code,{className:"language-rust",children:'let komodo = KomodoClient::new("https://demo.komo.do", "your_key", "your_secret")\n  .with_healthcheck()\n  .await?;\n\nlet stacks = komodo.read(ListStacks::default()).await?;\n\nlet update = komodo\n  .execute(DeployStack {\n    stack: stacks[0].name.clone(),\n    stop_time: None\n  })\n  .await?;\n'})}),"\n",(0,o.jsx)(t.h2,{id:"typescript-client",children:"Typescript Client"}),"\n",(0,o.jsxs)(t.p,{children:["The Typescript client is published to NPM at ",(0,o.jsx)(t.a,{href:"https://www.npmjs.com/package/komodo_client",children:"komodo_client"}),"."]}),"\n",(0,o.jsx)(t.pre,{children:(0,o.jsx)(t.code,{className:"language-ts",children:'import { KomodoClient, Types } from "komodo_client";\n\nconst komodo = KomodoClient("https://demo.komo.do", {\n  type: "api-key",\n  params: {\n    key: "your_key",\n    secret: "your secret",\n  },\n});\n\n// Inferred as Types.StackListItem[]\nconst stacks = await komodo.read("ListStacks", {});\n\n// Inferred as Types.Update\nconst update = await komodo.execute("DeployStack", {\n  stack: stacks[0].name,\n});\n'})})]})}function p(e={}){const{wrapper:t}={...(0,c.R)(),...e.components};return t?(0,o.jsx)(t,{...e,children:(0,o.jsx)(l,{...e})}):l(e)}},8453:(e,t,n)=>{n.d(t,{R:()=>i,x:()=>a});var s=n(6540);const o={},c=s.createContext(o);function i(e){const t=s.useContext(c);return s.useMemo(function(){return"function"==typeof e?e(t):{...t,...e}},[t,e])}function a(e){let t;return t=e.disableParentContext?"function"==typeof e.components?e.components(o):e.components||o:i(e.components),s.createElement(c.Provider,{value:t},e.children)}}}]);

assets/js/809.dd000c0d.js

@@ -0,0 +1 @@
+(()=>{"use strict";var e,r,t={4809:(e,r,t)=>{t.d(r,{BH:()=>s,Ho:()=>a,IH:()=>n,sx:()=>o});t(8291);const o=[],s=["en"],n="search-index{dir}.json?_=e0b82467",a=1}},o={};function s(e){var r=o[e];if(void 0!==r)return r.exports;var n=o[e]={exports:{}};return t[e](n,n.exports,s),n.exports}s.m=t,s.x=()=>{var e=s.O(void 0,[540],()=>s(540));return e=s.O(e)},e=[],s.O=(r,t,o,n)=>{if(!t){var a=1/0;for(u=0;u<e.length;u++){t=e[u][0],o=e[u][1],n=e[u][2];for(var i=!0,p=0;p<t.length;p++)(!1&n||a>=n)&&Object.keys(s.O).every(e=>s.O[e](t[p]))?t.splice(p--,1):(i=!1,n<a&&(a=n));if(i){e.splice(u--,1);var f=o();void 0!==f&&(r=f)}}return r}n=n||0;for(var u=e.length;u>0&&e[u-1][2]>n;u--)e[u]=e[u-1];e[u]=[t,o,n]},s.n=e=>{var r=e&&e.__esModule?()=>e.default:()=>e;return s.d(r,{a:r}),r},s.d=(e,r)=>{for(var t in r)s.o(r,t)&&!s.o(e,t)&&Object.defineProperty(e,t,{enumerable:!0,get:r[t]})},s.f={},s.e=e=>Promise.all(Object.keys(s.f).reduce((r,t)=>(s.f[t](e,r),r),[])),s.u=e=>"assets/js/"+e+".d8cc415a.js",s.miniCssF=e=>{},s.o=(e,r)=>Object.prototype.hasOwnProperty.call(e,r),s.p="/",s.gca=function(e){return e={}[e]||e,s.p+s.u(e)},(()=>{var e={809:1};s.f.i=(r,t)=>{e[r]||importScripts(s.p+s.u(r))};var r=self.webpackChunkdocsite=self.webpackChunkdocsite||[],t=r.push.bind(r);r.push=r=>{var o=r[0],n=r[1],a=r[2];for(var i in n)s.o(n,i)&&(s.m[i]=n[i]);for(a&&a(s);o.length;)e[o.pop()]=1;t(r)}})(),r=s.x,s.x=()=>s.e(540).then(r);s.x()})();

assets/js/a7456010.b82eb55b.js

@@ -0,0 +1 @@
+"use strict";(self.webpackChunkdocsite=self.webpackChunkdocsite||[]).push([[235],{8552:e=>{e.exports=JSON.parse('{"name":"docusaurus-plugin-content-pages","id":"default"}')}}]);

assets/js/a7bd4aaa.9eafbbe0.js

@@ -0,0 +1 @@
+"use strict";(self.webpackChunkdocsite=self.webpackChunkdocsite||[]).push([[98],{1723:(n,e,s)=>{s.r(e),s.d(e,{default:()=>l});s(6540);var r=s(5500);function o(n,e){return`docs-${n}-${e}`}var t=s(3025),c=s(2831),i=s(1463),u=s(4848);function a(n){const{version:e}=n;return(0,u.jsxs)(u.Fragment,{children:[(0,u.jsx)(i.A,{version:e.version,tag:o(e.pluginId,e.version)}),(0,u.jsx)(r.be,{children:e.noIndex&&(0,u.jsx)("meta",{name:"robots",content:"noindex, nofollow"})})]})}function d(n){const{version:e,route:s}=n;return(0,u.jsx)(r.e3,{className:e.className,children:(0,u.jsx)(t.n,{version:e,children:(0,c.v)(s.routes)})})}function l(n){return(0,u.jsxs)(u.Fragment,{children:[(0,u.jsx)(a,{...n}),(0,u.jsx)(d,{...n})]})}}}]);

assets/js/aba21aa0.e2256b29.js

@@ -0,0 +1 @@
+"use strict";(self.webpackChunkdocsite=self.webpackChunkdocsite||[]).push([[742],{7093:e=>{e.exports=JSON.parse('{"name":"docusaurus-plugin-content-docs","id":"default"}')}}]);

assets/js/ce26f959.ae637a7f.js

@@ -0,0 +1 @@
+"use strict";(self.webpackChunkdocsite=self.webpackChunkdocsite||[]).push([[850],{7868:(e,t,n)=>{n.r(t),n.d(t,{assets:()=>i,contentTitle:()=>d,default:()=>u,frontMatter:()=>a,metadata:()=>o,toc:()=>c});const o=JSON.parse('{"id":"deploy/auto-update","title":"Automatic Updates","description":"Komodo can automatically check for newer Docker image digests and redeploy resources when updates are found.","source":"@site/docs/deploy/auto-update.md","sourceDirName":"deploy","slug":"/deploy/auto-update","permalink":"/docs/deploy/auto-update","draft":false,"unlisted":false,"editUrl":"https://github.com/moghtech/komodo/tree/main/docsite/docs/deploy/auto-update.md","tags":[],"version":"current","frontMatter":{},"sidebar":"docs","previous":{"title":"Containers","permalink":"/docs/deploy/containers"},"next":{"title":"Swarm","permalink":"/docs/swarm"}}');var r=n(4848),s=n(8453);const a={},d="Automatic Updates",i={},c=[{value:"Configuration",id:"configuration",level:2},{value:"Global Auto Update Procedure",id:"global-auto-update-procedure",level:2}];function l(e){const t={a:"a",admonition:"admonition",code:"code",h1:"h1",h2:"h2",header:"header",p:"p",pre:"pre",strong:"strong",table:"table",tbody:"tbody",td:"td",th:"th",thead:"thead",tr:"tr",...(0,s.R)(),...e.components};return(0,r.jsxs)(r.Fragment,{children:[(0,r.jsx)(t.header,{children:(0,r.jsx)(t.h1,{id:"automatic-updates",children:"Automatic Updates"})}),"\n",(0,r.jsx)(t.p,{children:"Komodo can automatically check for newer Docker image digests and redeploy resources when updates are found."}),"\n",(0,r.jsx)(t.h2,{id:"configuration",children:"Configuration"}),"\n",(0,r.jsxs)(t.p,{children:["Both ",(0,r.jsx)(t.strong,{children:"Stacks"})," and ",(0,r.jsx)(t.strong,{children:"Deployments"})," support two update modes:"]}),"\n",(0,r.jsxs)(t.table,{children:[(0,r.jsx)(t.thead,{children:(0,r.jsxs)(t.tr,{children:[(0,r.jsx)(t.th,{children:"Mode"}),(0,r.jsx)(t.th,{children:"Behavior"})]})}),(0,r.jsxs)(t.tbody,{children:[(0,r.jsxs)(t.tr,{children:[(0,r.jsx)(t.td,{children:(0,r.jsx)(t.strong,{children:"Poll for Updates"})}),(0,r.jsx)(t.td,{children:"Checks for newer images with the same tag. Displays an update indicator in the UI and sends an alert (if an Alerter is configured). Does not redeploy."})]}),(0,r.jsxs)(t.tr,{children:[(0,r.jsx)(t.td,{children:(0,r.jsx)(t.strong,{children:"Auto Update"})}),(0,r.jsx)(t.td,{children:"Same check, but automatically redeploys services with newer images. Also sends an alert."})]})]})]}),"\n",(0,r.jsx)(t.admonition,{type:"note",children:(0,r.jsxs)(t.p,{children:['Auto-update requires a "rolling" image tag like ',(0,r.jsx)(t.code,{children:":latest"}),". For pinned tags in git-sourced stacks, consider ",(0,r.jsx)(t.a,{href:"https://github.com/renovatebot/renovate",children:"Renovate"}),"."]})}),"\n",(0,r.jsx)(t.h2,{id:"global-auto-update-procedure",children:"Global Auto Update Procedure"}),"\n",(0,r.jsxs)(t.p,{children:["New installs include a ",(0,r.jsx)(t.strong,{children:"Global Auto Update"})," Procedure, scheduled daily. It loops through all resources with either mode enabled and checks registries for newer digests."]}),"\n",(0,r.jsx)(t.pre,{children:(0,r.jsx)(t.code,{className:"language-toml",children:'[[procedure]]\nname = "Global Auto Update"\ndescription = "Pulls and auto updates Stacks and Deployments using \'poll_for_updates\' or \'auto_update\'."\ntags = ["system"]\nconfig.schedule = "Every day at 03:00"\n\n[[procedure.config.stage]]\nname = "Stage 1"\nenabled = true\nexecutions = [\n  { execution.type = "GlobalAutoUpdate", execution.params = {}, enabled = true }\n]\n'})}),"\n",(0,r.jsx)(t.admonition,{type:"info",children:(0,r.jsxs)(t.p,{children:[(0,r.jsx)(t.code,{children:"GlobalAutoUpdate"})," can be integrated into other Procedures to coordinate timing with processes like backups. There is nothing special about the default Procedure \u2014 it is created for convenience."]})})]})}function u(e={}){const{wrapper:t}={...(0,s.R)(),...e.components};return t?(0,r.jsx)(t,{...e,children:(0,r.jsx)(l,{...e})}):l(e)}},8453:(e,t,n)=>{n.d(t,{R:()=>a,x:()=>d});var o=n(6540);const r={},s=o.createContext(r);function a(e){const t=o.useContext(s);return o.useMemo(function(){return"function"==typeof e?e(t):{...t,...e}},[t,e])}function d(e){let t;return t=e.disableParentContext?"function"==typeof e.components?e.components(r):e.components||r:a(e.components),o.createElement(s.Provider,{value:t},e.children)}}}]);

assets/js/main.0eb432bc.js.LICENSE.txt

@@ -0,0 +1,129 @@
+/* NProgress, (c) 2013, 2014 Rico Sta. Cruz - http://ricostacruz.com/nprogress
+ * @license MIT */
+
+/*!
+ * lunr.Builder
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/*!
+ * lunr.Index
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/*!
+ * lunr.Pipeline
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/*!
+ * lunr.Set
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/*!
+ * lunr.TokenSet
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/*!
+ * lunr.Vector
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/*!
+ * lunr.stemmer
+ * Copyright (C) 2020 Oliver Nightingale
+ * Includes code from - http://tartarus.org/~martin/PorterStemmer/js.txt
+ */
+
+/*!
+ * lunr.stopWordFilter
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/*!
+ * lunr.tokenizer
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/*!
+ * lunr.trimmer
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/*!
+ * lunr.utils
+ * Copyright (C) 2020 Oliver Nightingale
+ */
+
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @license React
+ * react-dom-client.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * @license React
+ * react-dom.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * @license React
+ * react-jsx-runtime.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * @license React
+ * react.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * @license React
+ * scheduler.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * lunr - http://lunrjs.com - A bit like Solr, but much smaller and not as bright - 2.3.9
+ * Copyright (C) 2020 Oliver Nightingale
+ * @license MIT
+ */
+
+/** @license React v16.13.1
+ * react-is.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */

bin/binaries.Dockerfile

@@ -1,33 +0,0 @@
-## Builds the Komodo Core, Periphery, and Util binaries
-## for a specific architecture. Requires OpenSSL 3 or later.
-
-FROM rust:1.97.1-bookworm AS builder
-RUN cargo install cargo-strip
-
-WORKDIR /builder
-COPY Cargo.toml Cargo.lock ./
-COPY ./lib ./lib
-COPY ./client/core/rs ./client/core/rs
-COPY ./client/periphery ./client/periphery
-COPY ./bin/core ./bin/core
-COPY ./bin/periphery ./bin/periphery
-COPY ./bin/cli ./bin/cli
-COPY ./xtask ./xtask
-
-# Compile bin
-RUN \
-  cargo build -p komodo_core --release && \
-  cargo build -p komodo_periphery --release && \
-  cargo build -p komodo_cli --release && \
-  cargo strip
-
-# Copy just the binaries to scratch image
-FROM scratch
-
-COPY --from=builder /builder/target/release/core /core
-COPY --from=builder /builder/target/release/periphery /periphery
-COPY --from=builder /builder/target/release/km /km
-
-LABEL org.opencontainers.image.source="https://github.com/moghtech/komodo"
-LABEL org.opencontainers.image.description="Komodo Binaries"
-LABEL org.opencontainers.image.licenses="GPL-3.0"

bin/chef.binaries.Dockerfile

@@ -1,36 +0,0 @@
-## Builds the Komodo Core, Periphery, and Util binaries
-## for a specific architecture. Requires OpenSSL 3 or later.
-
-## Uses chef for dependency caching to help speed up back-to-back builds.
-
-FROM lukemathwalker/cargo-chef:latest-rust-1.97.1-bookworm AS chef
-WORKDIR /builder
-
-# Plan just the RECIPE to see if things have changed
-FROM chef AS planner
-COPY . .
-RUN cargo chef prepare --recipe-path recipe.json
-
-FROM chef AS builder
-RUN cargo install cargo-strip
-COPY --from=planner /builder/recipe.json recipe.json
-# Build JUST dependencies - cached layer
-RUN cargo chef cook --release --recipe-path recipe.json
-# NOW copy again (this time into builder) and build app
-COPY . .
-RUN \
-  cargo build --release --bin core && \
-  cargo build --release --bin periphery && \
-  cargo build --release --bin km && \
-  cargo strip
-
-# Copy just the binaries to scratch image
-FROM scratch
-
-COPY --from=builder /builder/target/release/core /core
-COPY --from=builder /builder/target/release/periphery /periphery
-COPY --from=builder /builder/target/release/km /km
-
-LABEL org.opencontainers.image.source="https://github.com/moghtech/komodo"
-LABEL org.opencontainers.image.description="Komodo Binaries"
-LABEL org.opencontainers.image.licenses="GPL-3.0"

bin/cli/Cargo.toml

@@ -1,40 +0,0 @@
-[package]
-name = "komodo_cli"
-description = "Command line tool for Komodo"
-version.workspace = true
-edition.workspace = true
-license.workspace = true
-repository.workspace = true
-homepage.workspace = true
-
-[[bin]]
-name = "km"
-path = "src/main.rs"
-
-[dependencies]
-# local
-komodo_client = { workspace = true, features = ["cli"] }
-mogh_secret_file.workspace = true
-mogh_pki.workspace = true
-database.workspace = true
-mogh_config.workspace = true
-mogh_logger.workspace = true
-# external
-futures-util.workspace = true
-comfy-table.workspace = true
-tokio-util.workspace = true
-serde_json.workspace = true
-crossterm.workspace = true
-serde_qs.workspace = true
-wildcard.workspace = true
-tracing.workspace = true
-colored.workspace = true
-dotenvy.workspace = true
-anyhow.workspace = true
-bcrypt.workspace = true
-chrono.workspace = true
-rustls.workspace = true
-tokio.workspace = true
-serde.workspace = true
-clap.workspace = true
-envy.workspace = true

bin/cli/README.md

@@ -1,118 +0,0 @@
-# Komodo CLI
-
-Komodo CLI is a tool to execute actions on your Komodo instance from shell scripts.
-
-## Install
-
-```sh
-cargo install komodo_cli
-```
-
-Note: On Ubuntu, also requires `apt install build-essential pkg-config libssl-dev`.
-
-## Usage
-
-### Credentials
-
-Configure a file `~/.config/komodo/creds.toml` file with contents:
-```toml
-url = "https://your.komodo.address"
-key = "YOUR-API-KEY"
-secret = "YOUR-API-SECRET"
-```
-
-Note. You can specify a different creds file by using `--creds ./other/path.toml`.
-You can also bypass using any file and pass the information using `--url`, `--key`, `--secret`:
-
-```sh
-komodo --url "https://your.komodo.address" --key "YOUR-API-KEY" --secret "YOUR-API-SECRET" ...
-```
-
-### Run Executions
-
-```sh
-# Triggers an example build
-komodo execute run-build test_build
-```
-
-#### Manual
-`komodo --help`
-```md
-Command line tool to execute Komodo actions
-
-Usage: komodo [OPTIONS] <COMMAND>
-
-Commands:
-  execute  Runs an execution
-  help     Print this message or the help of the given subcommand(s)
-
-Options:
-      --creds <CREDS>    The path to a creds file [default: /Users/max/.config/komodo/creds.toml]
-      --url <URL>        Pass url in args instead of creds file
-      --key <KEY>        Pass api key in args instead of creds file
-      --secret <SECRET>  Pass api secret in args instead of creds file
-  -y, --yes              Always continue on user confirmation prompts
-  -h, --help             Print help (see more with '--help')
-  -V, --version          Print version
-```
-
-`komodo execute --help`
-```md
-Runs an execution
-
-Usage: komodo execute <COMMAND>
-
-Commands:
-  none                    The "null" execution. Does nothing
-  run-procedure           Runs the target procedure. Response: [Update]
-  run-build               Runs the target build. Response: [Update]
-  cancel-build            Cancels the target build. Only does anything if the build is `building` when called. Response: [Update]
-  deploy                  Deploys the container for the target deployment. Response: [Update]
-  start-deployment        Starts the container for the target deployment. Response: [Update]
-  restart-deployment      Restarts the container for the target deployment. Response: [Update]
-  pause-deployment        Pauses the container for the target deployment. Response: [Update]
-  unpause-deployment      Unpauses the container for the target deployment. Response: [Update]
-  stop-deployment         Stops the container for the target deployment. Response: [Update]
-  destroy-deployment      Stops and destroys the container for the target deployment. Reponse: [Update]
-  clone-repo              Clones the target repo. Response: [Update]
-  pull-repo               Pulls the target repo. Response: [Update]
-  build-repo              Builds the target repo, using the attached builder. Response: [Update]
-  cancel-repo-build       Cancels the target repo build. Only does anything if the repo build is `building` when called. Response: [Update]
-  start-container         Starts the container on the target server. Response: [Update]
-  restart-container       Restarts the container on the target server. Response: [Update]
-  pause-container         Pauses the container on the target server. Response: [Update]
-  unpause-container       Unpauses the container on the target server. Response: [Update]
-  stop-container          Stops the container on the target server. Response: [Update]
-  destroy-container       Stops and destroys the container on the target server. Reponse: [Update]
-  start-all-containers    Starts all containers on the target server. Response: [Update]
-  restart-all-containers  Restarts all containers on the target server. Response: [Update]
-  pause-all-containers    Pauses all containers on the target server. Response: [Update]
-  unpause-all-containers  Unpauses all containers on the target server. Response: [Update]
-  stop-all-containers     Stops all containers on the target server. Response: [Update]
-  prune-containers        Prunes the docker containers on the target server. Response: [Update]
-  delete-network          Delete a docker network. Response: [Update]
-  prune-networks          Prunes the docker networks on the target server. Response: [Update]
-  delete-image            Delete a docker image. Response: [Update]
-  prune-images            Prunes the docker images on the target server. Response: [Update]
-  delete-volume           Delete a docker volume. Response: [Update]
-  prune-volumes           Prunes the docker volumes on the target server. Response: [Update]
-  prune-system            Prunes the docker system on the target server, including volumes. Response: [Update]
-  run-sync                Runs the target resource sync. Response: [Update]
-  deploy-stack            Deploys the target stack. `docker compose up`. Response: [Update]
-  start-stack             Starts the target stack. `docker compose start`. Response: [Update]
-  restart-stack           Restarts the target stack. `docker compose restart`. Response: [Update]
-  pause-stack             Pauses the target stack. `docker compose pause`. Response: [Update]
-  unpause-stack           Unpauses the target stack. `docker compose unpause`. Response: [Update]
-  stop-stack              Starts the target stack. `docker compose stop`. Response: [Update]
-  destroy-stack           Destoys the target stack. `docker compose down`. Response: [Update]
-  sleep                   
-  help                    Print this message or the help of the given subcommand(s)
-
-Options:
-  -h, --help  Print help
-```
-
-### --yes
-
-You can use `--yes` to avoid any human prompt to continue, for use in automated environments.
-

bin/cli/aio.Dockerfile

@@ -1,25 +0,0 @@
-FROM rust:1.97.1-trixie AS builder
-RUN cargo install cargo-strip
-
-WORKDIR /builder
-COPY Cargo.toml Cargo.lock ./
-COPY ./lib ./lib
-COPY ./client/core/rs ./client/core/rs
-COPY ./client/periphery ./client/periphery
-COPY ./bin/cli ./bin/cli
-
-# Compile bin
-RUN cargo build -p komodo_cli --release && cargo strip
-
-# Copy binaries to distroless base
-FROM gcr.io/distroless/cc
-
-COPY --from=builder /builder/target/release/km /usr/local/bin/km
-
-ENV KOMODO_CLI_CONFIG_PATHS="/config"
-
-CMD [ "km" ]
-
-LABEL org.opencontainers.image.source="https://github.com/moghtech/komodo"
-LABEL org.opencontainers.image.description="Komodo CLI"
-LABEL org.opencontainers.image.licenses="GPL-3.0"

bin/cli/docs/copy-database.md

@@ -1,135 +0,0 @@
-# Copy Database Utility
-
-Copy the Komodo database contents between running, mongo-compatible databases.
-Can be used to move between MongoDB / FerretDB, or upgrade from FerretDB v1 to v2.
-
-```yaml
-services:
-
-  copy_database:
-    image: ghcr.io/moghtech/komodo-cli
-    command: km database copy -y
-    environment:
-      KOMODO_DATABASE_URI: mongodb://${KOMODO_DB_USERNAME}:${KOMODO_DB_PASSWORD}@source:27017
-      KOMODO_DATABASE_DB_NAME: ${KOMODO_DATABASE_DB_NAME:-komodo}
-      KOMODO_CLI_DATABASE_TARGET_URI: mongodb://${KOMODO_DB_USERNAME}:${KOMODO_DB_PASSWORD}@target:27017
-      KOMODO_CLI_DATABASE_TARGET_DB_NAME: ${KOMODO_DATABASE_DB_NAME:-komodo}
-
-```
-
-## FerretDB v2 Update Guide
-
-Up to Komodo 1.17.5, users who wanted to use Postgres / Sqlite were instructed to deploy FerretDB v1.
-Now that v2 is out however, v1 will go largely unsupported. Users are recommended to migrate to v2 for
-the best performance and ongoing support / updates, however the internal data structures
-have changed and this cannot be done in-place. 
-
-Also note that FerretDB v2 no longer supports Sqlite, and only supports 
-a [customized Postgres distribution](https://docs.ferretdb.io/installation/documentdb/docker/).
-Nonetheless, it remains a solid option for hosts which [do not support mongo](https://github.com/moghtech/komodo/issues/59).
-
-Also note, the same basic process outlined below can also be used to move between MongoDB and FerretDB, just replace FerretDB v2
-with the database you wish to move to.
-
-### **Step 1**: *Add* the new database to the top of your existing Komodo compose file.
-
-**Don't forget to also add the new volumes.**
-
-```yaml
-## In Komodo compose.yaml
-services:
-  postgres2:
-    # Recommended: Pin to a specific version
-    # https://github.com/FerretDB/documentdb/pkgs/container/postgres-documentdb
-    image: ghcr.io/ferretdb/postgres-documentdb
-    labels:
-      komodo.skip: # Prevent Komodo from stopping with StopAllContainers
-    restart: unless-stopped
-    # ports:
-    #   - 5432:5432
-    volumes:
-      - postgres-data:/var/lib/postgresql/data
-    environment:
-      POSTGRES_USER: ${KOMODO_DB_USERNAME}
-      POSTGRES_PASSWORD: ${KOMODO_DB_PASSWORD}
-      POSTGRES_DB: postgres # Do not change
-
-  ferretdb2:
-    # Recommended: Pin to a specific version
-    # https://github.com/FerretDB/FerretDB/pkgs/container/ferretdb
-    image: ghcr.io/ferretdb/ferretdb
-    labels:
-      komodo.skip: # Prevent Komodo from stopping with StopAllContainers
-    restart: unless-stopped
-    depends_on:
-      - postgres2
-    # ports:
-    #   - 27017:27017
-    volumes:
-      - ferretdb-state:/state
-    environment:
-      FERRETDB_POSTGRESQL_URL: postgres://${KOMODO_DB_USERNAME}:${KOMODO_DB_PASSWORD}@postgres2:5432/postgres
-
-  ...(unchanged)
-
-volumes:
-  ...(unchanged)
-  postgres-data:
-  ferretdb-state:
-```
-
-### **Step 2**: *Add* the database copy utility to Komodo compose file.
-
-The SOURCE_URI points to the existing database, ie the old FerretDB v1, and it depends
-on whether it was deployed using Postgres or Sqlite. The example below uses the Postgres one,
-but if you use Sqlite it should just be something like `mongodb://ferretdb:27017`.
-
-```yaml
-## In Komodo compose.yaml
-services:
-  ...(new database)
-
-  copy_database:
-    image: ghcr.io/moghtech/komodo-cli
-    command: km database copy -y
-    environment:
-      KOMODO_DATABASE_URI: mongodb://${KOMODO_DB_USERNAME}:${KOMODO_DB_PASSWORD}@ferretdb:27017/${KOMODO_DATABASE_DB_NAME:-komodo}?authMechanism=PLAIN
-      KOMODO_DATABASE_DB_NAME: ${KOMODO_DATABASE_DB_NAME:-komodo}
-      KOMODO_CLI_DATABASE_TARGET_URI: mongodb://${KOMODO_DB_USERNAME}:${KOMODO_DB_PASSWORD}@ferretdb2:27017
-      KOMODO_CLI_DATABASE_TARGET_DB_NAME: ${KOMODO_DATABASE_DB_NAME:-komodo}
-
-  ...(unchanged)
-```
-
-### **Step 3**: *Compose Up* the new additions
-
-Run `docker compose -p komodo --env-file compose.env -f xxxxx.compose.yaml up -d`, filling in the name of your compose.yaml.
-This will start up both the old and new database, and copy the data to the new one.
-
-Wait a few moments for the `copy_database` service to finish. When it exits,
-confirm the logs show the data was moved successfully, and move on to the next step.
-
-### **Step 4**: Point Komodo Core to the new database
-
-In your Komodo compose.yaml, first *comment out* the `copy_database` service and old ferretdb v1 service/s.
-Then update the `core` service environment to point to `ferretdb2`.
-
-```yaml
-services:
-  ...
-
-  core:
-    ...(unchanged)
-    environment:
-      KOMODO_DATABASE_ADDRESS: ferretdb2:27017
-      KOMODO_DATABASE_USERNAME: ${KOMODO_DB_USERNAME}
-      KOMODO_DATABASE_PASSWORD: ${KOMODO_DB_PASSWORD}
-```
-
-### **Step 5**: Final *Compose Up*
-
-Repeat the same `docker compose` command as before to apply the changes, and then try navigating to your Komodo web page.
-If it works, congrats, **you are done**. You can clean up the compose file if you would like, removing the old volumes etc.
-
-If it does not work, check the logs for any obvious issues, and if necessary you can undo the previous steps
-to go back to using the previous database.

bin/cli/multi-arch.Dockerfile

@@ -1,29 +0,0 @@
-## Assumes the latest binaries for x86_64 and aarch64 are already built (by binaries.Dockerfile).
-## Since theres no heavy build here, QEMU multi-arch builds are fine for this image.
-
-ARG BINARIES_IMAGE=ghcr.io/moghtech/komodo-binaries:2
-ARG X86_64_BINARIES=${BINARIES_IMAGE}-x86_64
-ARG AARCH64_BINARIES=${BINARIES_IMAGE}-aarch64
-
-# This is required to work with COPY --from
-FROM ${X86_64_BINARIES} AS x86_64
-FROM ${AARCH64_BINARIES} AS aarch64
-
-FROM debian:trixie-slim
-
-WORKDIR /app
-
-## Copy both binaries initially, but only keep appropriate one for the TARGETPLATFORM.
-COPY --from=x86_64 /km /app/arch/linux/amd64
-COPY --from=aarch64 /km /app/arch/linux/arm64
-
-ARG TARGETPLATFORM
-RUN mv /app/arch/${TARGETPLATFORM} /usr/local/bin/km && rm -r /app/arch
-
-ENV KOMODO_CLI_CONFIG_PATHS="/config"
-
-CMD [ "km" ]
-
-LABEL org.opencontainers.image.source="https://github.com/moghtech/komodo"
-LABEL org.opencontainers.image.description="Komodo CLI"
-LABEL org.opencontainers.image.licenses="GPL-3.0"

bin/cli/runfile.toml

@@ -1,4 +0,0 @@
-[install-cli]
-alias = "ic"
-description = "installs the komodo-cli, available on the command line as 'km'"
-cmd = "cargo install --path ."

bin/cli/single-arch.Dockerfile

@@ -1,18 +0,0 @@
-## Assumes the latest binaries for the required arch are already built (by binaries.Dockerfile).
-
-ARG BINARIES_IMAGE=ghcr.io/moghtech/komodo-binaries:2
-
-# This is required to work with COPY --from
-FROM ${BINARIES_IMAGE} AS binaries
-
-FROM gcr.io/distroless/cc
-
-COPY --from=binaries /km /usr/local/bin/km
-
-ENV KOMODO_CLI_CONFIG_PATHS="/config"
-
-CMD [ "km" ]
-
-LABEL org.opencontainers.image.source="https://github.com/moghtech/komodo"
-LABEL org.opencontainers.image.description="Komodo CLI"
-LABEL org.opencontainers.image.licenses="GPL-3.0"

bin/cli/src/command/container.rs

@@ -1,312 +0,0 @@
-use std::collections::{HashMap, HashSet};
-
-use anyhow::Context;
-use colored::Colorize;
-use comfy_table::{Attribute, Cell, Color};
-use futures_util::{
-  FutureExt, TryStreamExt, stream::FuturesUnordered,
-};
-use komodo_client::{
-  api::read::{self, ListAllContainers, ListServers},
-  entities::{
-    config::cli::args::container::{
-      Container, ContainerCommand, InspectContainer,
-    },
-    docker::{
-      self,
-      container::{
-        ContainerListItem, ContainerSortBy, ContainerStateStatusEnum,
-      },
-    },
-  },
-};
-
-use crate::{
-  command::{
-    PrintTable, clamp_sha, matches_wildcards, parse_wildcards,
-    print_items,
-  },
-  config::cli_config,
-};
-
-pub async fn handle(container: &Container) -> anyhow::Result<()> {
-  match &container.command {
-    None => list_containers(container).await,
-    Some(ContainerCommand::Inspect(inspect)) => {
-      inspect_container(inspect).await
-    }
-  }
-}
-
-async fn list_containers(
-  Container {
-    all,
-    down,
-    links,
-    reverse,
-    containers: terms,
-    images,
-    networks,
-    servers,
-    format,
-    page,
-    command: _,
-  }: &Container,
-) -> anyhow::Result<()> {
-  let client = super::komodo_client().await?;
-  let (server_map, containers) = tokio::try_join!(
-    client
-      .read(ListServers::default())
-      .map(|res| res.map(|res| res
-        .into_iter()
-        .map(|s| (s.id.clone(), s))
-        .collect::<HashMap<_, _>>())),
-    client.read(ListAllContainers {
-      servers: Default::default(),
-      tags: Default::default(),
-      terms: terms.clone(),
-      state: Default::default(),
-      limit: Some(100),
-      // Page is more naturally given starting as 1, 2, 3.
-      page: if *page == 0 { 0 } else { *page - 1 },
-      sort_by: ContainerSortBy::Server,
-      sort_desc: false,
-    }),
-  )?;
-
-  // (Option<Server Name>, Container)
-  let containers = containers.into_iter().map(|c| {
-    let server = if let Some(server_id) = c.server_id.as_ref()
-      && let Some(server) = server_map.get(server_id)
-    {
-      server
-    } else {
-      return (None, c);
-    };
-    (Some(server.name.as_str()), c)
-  });
-
-  let servers = parse_wildcards(servers);
-  let images = parse_wildcards(images);
-  let networks = parse_wildcards(networks);
-
-  let mut containers = containers
-    .into_iter()
-    .filter(|(server_name, c)| {
-      let state_check = if *all {
-        true
-      } else if *down {
-        !matches!(c.state, ContainerStateStatusEnum::Running)
-      } else {
-        matches!(c.state, ContainerStateStatusEnum::Running)
-      };
-      let network_check = matches_wildcards(
-        &networks,
-        &c.network_mode
-          .as_deref()
-          .map(|n| vec![n])
-          .unwrap_or_default(),
-      ) || matches_wildcards(
-        &networks,
-        &c.networks.iter().map(String::as_str).collect::<Vec<_>>(),
-      );
-      state_check
-        && network_check
-        && matches_wildcards(
-          &servers,
-          &server_name
-            .as_deref()
-            .map(|i| vec![i])
-            .unwrap_or_default(),
-        )
-        && matches_wildcards(
-          &images,
-          &c.image.as_deref().map(|i| vec![i]).unwrap_or_default(),
-        )
-    })
-    .collect::<Vec<_>>();
-  containers.sort_by(|(a_s, a), (b_s, b)| {
-    a.state
-      .cmp(&b.state)
-      .then(a.name.cmp(&b.name))
-      .then(a_s.cmp(b_s))
-      .then(a.network_mode.cmp(&b.network_mode))
-      .then(a.image.cmp(&b.image))
-  });
-  if *reverse {
-    containers.reverse();
-  }
-  print_items(containers, *format, *links)?;
-  Ok(())
-}
-
-pub async fn inspect_container(
-  inspect: &InspectContainer,
-) -> anyhow::Result<()> {
-  let client = super::komodo_client().await?;
-  let (server_map, mut containers) = tokio::try_join!(
-    client
-      .read(ListServers::default())
-      .map(|res| res.map(|res| res
-        .into_iter()
-        .map(|s| (s.id.clone(), s))
-        .collect::<HashMap<_, _>>())),
-    client.read(ListAllContainers {
-      servers: inspect.servers.clone(),
-      tags: Default::default(),
-      terms: vec![inspect.container.clone()],
-      state: Default::default(),
-      limit: Some(0),
-      page: 0,
-      sort_by: ContainerSortBy::Server,
-      sort_desc: false,
-    }),
-  )?;
-
-  containers.iter_mut().for_each(|c| {
-    let Some(server_id) = c.server_id.as_ref() else {
-      return;
-    };
-    let Some(server) = server_map.get(server_id) else {
-      c.server_id = Some(String::from("Unknown"));
-      return;
-    };
-    c.server_id = Some(server.name.clone());
-  });
-
-  let mut containers = containers
-    .into_iter()
-    .map(|c| async move {
-      client
-        .read(read::InspectContainer {
-          container: c.name,
-          server: c.server_id.context("No server...")?,
-        })
-        .await
-    })
-    .collect::<FuturesUnordered<_>>()
-    .try_collect::<Vec<_>>()
-    .await?;
-
-  containers.sort_by(|a, b| a.name.cmp(&b.name));
-
-  match containers.len() {
-    0 => {
-      println!(
-        "{}: Did not find any containers matching '{}'",
-        "INFO".green(),
-        inspect.container.bold()
-      );
-    }
-    1 => {
-      println!("{}", serialize_container(inspect, &containers[0])?);
-    }
-    _ => {
-      let containers = containers
-        .iter()
-        .map(|c| serialize_container(inspect, c))
-        .collect::<anyhow::Result<Vec<_>>>()?
-        .join("\n");
-      println!("{containers}");
-    }
-  }
-
-  Ok(())
-}
-
-fn serialize_container(
-  inspect: &InspectContainer,
-  container: &docker::container::Container,
-) -> anyhow::Result<String> {
-  let res = if inspect.state {
-    serde_json::to_string_pretty(&container.state)
-  } else if inspect.mounts {
-    serde_json::to_string_pretty(&container.mounts)
-  } else if inspect.host_config {
-    serde_json::to_string_pretty(&container.host_config)
-  } else if inspect.config {
-    serde_json::to_string_pretty(&container.config)
-  } else if inspect.network_settings {
-    serde_json::to_string_pretty(&container.network_settings)
-  } else {
-    serde_json::to_string_pretty(container)
-  }
-  .context("Failed to serialize items to JSON")?;
-  Ok(res)
-}
-
-// (Option<Server Name>, Container)
-impl PrintTable for (Option<&'_ str>, ContainerListItem) {
-  fn header(links: bool) -> &'static [&'static str] {
-    if links {
-      &[
-        "Container",
-        "State",
-        "Server",
-        "Ports",
-        "Networks",
-        "Image",
-        "Link",
-      ]
-    } else {
-      &["Container", "State", "Server", "Ports", "Networks", "Image"]
-    }
-  }
-  fn row(self, links: bool) -> Vec<Cell> {
-    let color = match self.1.state {
-      ContainerStateStatusEnum::Running => Color::Green,
-      ContainerStateStatusEnum::Paused => Color::DarkYellow,
-      ContainerStateStatusEnum::Empty => Color::Grey,
-      _ => Color::Red,
-    };
-    let mut networks = HashSet::new();
-    if let Some(network) = self.1.network_mode {
-      networks.insert(network);
-    }
-    for network in self.1.networks {
-      networks.insert(network);
-    }
-    let mut networks = networks.into_iter().collect::<Vec<_>>();
-    networks.sort();
-    let mut ports = self
-      .1
-      .ports
-      .into_iter()
-      .flat_map(|p| p.public_port.map(|p| p.to_string()))
-      .collect::<HashSet<_>>()
-      .into_iter()
-      .collect::<Vec<_>>();
-    ports.sort();
-    let ports = if ports.is_empty() {
-      Cell::new("")
-    } else {
-      Cell::new(format!(":{}", ports.join(", :")))
-    };
-
-    let image = self.1.image.as_deref().unwrap_or("Unknown");
-    let mut res = vec![
-      Cell::new(self.1.name.clone()).add_attribute(Attribute::Bold),
-      Cell::new(self.1.state.to_string())
-        .fg(color)
-        .add_attribute(Attribute::Bold),
-      Cell::new(self.0.unwrap_or("Unknown")),
-      ports,
-      Cell::new(networks.join(", ")),
-      Cell::new(clamp_sha(image)),
-    ];
-    if !links {
-      return res;
-    }
-    let link = if let Some(server_id) = self.1.server_id {
-      format!(
-        "{}/servers/{server_id}/container/{}",
-        cli_config().host,
-        self.1.name
-      )
-    } else {
-      String::new()
-    };
-    res.push(Cell::new(link));
-    res
-  }
-}

bin/cli/src/command/core_info.rs

@@ -1,13 +0,0 @@
-use anyhow::Context as _;
-use komodo_client::api::read::GetCoreInfo;
-
-pub async fn handle() -> anyhow::Result<()> {
-  let client = super::komodo_client().await?;
-  let info = client.read(GetCoreInfo {}).await?;
-  println!(
-    "{}",
-    serde_json::to_string_pretty(&info)
-      .context("Failed to serialize core info to JSON")?
-  );
-  Ok(())
-}

bin/cli/src/command/create/api_key.rs

@@ -1,101 +0,0 @@
-use anyhow::Context as _;
-use database::bson::doc;
-use komodo_client::{
-  api::read::FindUser,
-  entities::{
-    api_key::ApiKey, config::cli::args::create::CreateApiKey,
-    komodo_timestamp, random_string,
-  },
-};
-use serde_json::json;
-
-use crate::config::cli_config;
-
-pub async fn create(
-  CreateApiKey {
-    name,
-    for_user,
-    expires,
-    use_api,
-  }: &CreateApiKey,
-) -> anyhow::Result<()> {
-  let expires = if let Some(expires_days) = expires {
-    // now + expires in ms
-    komodo_timestamp() + expires_days * 24 * 60 * 60 * 1000
-  } else {
-    0
-  };
-
-  if *use_api {
-    // USE API
-    let client = crate::command::komodo_client().await?;
-
-    let keys = if let Some(username) = for_user {
-      // For service user
-      let user = client
-        .read(FindUser {
-          user: username.to_string(),
-        })
-        .await?;
-      client
-        .write(
-          komodo_client::api::write::CreateApiKeyForServiceUser {
-            user_id: user.id,
-            name: name.clone().unwrap_or_default(),
-            expires,
-          },
-        )
-        .await?
-    } else {
-      // For self
-      client
-        .auth_manage(komodo_client::api::auth::manage::CreateApiKey {
-          name: name.clone().unwrap_or_default(),
-          expires: expires as u64,
-        })
-        .await?
-    };
-
-    println!(
-      "{}",
-      serde_json::to_string_pretty(&keys)
-        .context("Failed to serialize api keys to JSON")?
-    );
-  } else {
-    // USE DATABASE
-    let db = database::Client::new(&cli_config().database).await?;
-
-    let user = db
-      .users
-      .find_one(doc! { "username": for_user })
-      .await
-      .context("Failed to query database for user")?
-      .context("No user found with given username")?;
-
-    let key = format!("K_{}_K", random_string(40));
-    let secret = format!("S_{}_S", random_string(40));
-    let hashed_secret = bcrypt::hash(&secret, 10)
-      .context("Failed at hashing secret string")?;
-
-    db.api_keys
-      .insert_one(&ApiKey {
-        name: name.clone().unwrap_or_default(),
-        user_id: user.id,
-        key: key.clone(),
-        secret: hashed_secret.clone(),
-        created_at: komodo_timestamp(),
-        expires,
-      })
-      .await?;
-
-    println!(
-      "{}",
-      serde_json::to_string_pretty(
-        &json!({ "key": key, "secret": secret })
-      )
-      .context("Failed to serialize api keys to JSON")?
-    );
-  }
-
-  Ok(())
-}

bin/cli/src/command/create/mod.rs

@@ -1,13 +0,0 @@
-use komodo_client::entities::config::cli::args::create::CreateCommand;
-
-mod api_key;
-mod onboarding_key;
-
-pub async fn handle(command: &CreateCommand) -> anyhow::Result<()> {
-  match command {
-    CreateCommand::ApiKey(api_key) => api_key::create(api_key).await,
-    CreateCommand::OnboardingKey(onboarding_key) => {
-      onboarding_key::create(onboarding_key).await
-    }
-  }
-}

bin/cli/src/command/create/onboarding_key.rs

@@ -1,46 +0,0 @@
-use anyhow::Context as _;
-use komodo_client::entities::{
-  config::cli::args::create::CreateOnboardingKey, komodo_timestamp,
-};
-
-pub async fn create(
-  CreateOnboardingKey {
-    name,
-    expires,
-    private_key,
-    tags,
-    privileged,
-    copy_server,
-    create_builder,
-  }: &CreateOnboardingKey,
-) -> anyhow::Result<()> {
-  let expires = if let Some(expires_days) = expires {
-    // now + expires in ms
-    komodo_timestamp() + expires_days * 24 * 60 * 60 * 1000
-  } else {
-    0
-  };
-
-  // USE API
-  let client = crate::command::komodo_client().await?;
-
-  let key = client
-    .write(komodo_client::api::write::CreateOnboardingKey {
-      name: name.clone().unwrap_or_default(),
-      expires,
-      private_key: private_key.clone(),
-      tags: tags.clone(),
-      privileged: *privileged,
-      copy_server: copy_server.clone().unwrap_or_default(),
-      create_builder: *create_builder,
-    })
-    .await?;
-
-  println!(
-    "{}",
-    serde_json::to_string_pretty(&key)
-      .context("Failed to serialize onboarding key to JSON")?
-  );
-
-  Ok(())
-}

bin/cli/src/command/database.rs

@@ -1,371 +0,0 @@
-use std::path::Path;
-
-use anyhow::Context;
-use colored::Colorize;
-use database::mungos::mongodb::bson::{Document, doc};
-use komodo_client::entities::{
-  config::cli::args::database::DatabaseCommand, optional_string,
-};
-
-use crate::{command::sanitize_uri, config::cli_config};
-
-pub async fn handle(command: &DatabaseCommand) -> anyhow::Result<()> {
-  match command {
-    DatabaseCommand::Backup { yes, .. } => backup(*yes).await,
-    DatabaseCommand::Restore {
-      restore_folder,
-      index,
-      yes,
-      ..
-    } => restore(restore_folder.as_deref(), *index, *yes).await,
-    DatabaseCommand::Prune { yes, .. } => prune(*yes).await,
-    DatabaseCommand::Copy { yes, index, .. } => {
-      copy(*index, *yes).await
-    }
-    DatabaseCommand::V1Downgrade { yes } => v1_downgrade(*yes).await,
-  }
-}
-
-async fn backup(yes: bool) -> anyhow::Result<()> {
-  let config = cli_config();
-
-  println!(
-    "\n🦎  {} Database {} Utility  🦎",
-    "Komodo".bold(),
-    "Backup".green().bold()
-  );
-  println!(
-    "\n{}\n",
-    " - Backup all database contents to gzip compressed files."
-      .dimmed()
-  );
-  if let Some(uri) = optional_string(&config.database.uri) {
-    println!("{}: {}", " - Source URI".dimmed(), sanitize_uri(&uri));
-  }
-  if let Some(address) = optional_string(&config.database.address) {
-    println!("{}: {address}", " - Source Address".dimmed());
-  }
-  if let Some(username) = optional_string(&config.database.username) {
-    println!("{}: {username}", " - Source Username".dimmed());
-  }
-  println!(
-    "{}: {}\n",
-    " - Source Db Name".dimmed(),
-    config.database.db_name,
-  );
-  println!(
-    "{}: {:?}",
-    " - Backups Folder".dimmed(),
-    config.backups_folder
-  );
-  if config.max_backups == 0 {
-    println!(
-      "{}{}",
-      " - Backup pruning".dimmed(),
-      "disabled".red().dimmed()
-    );
-  } else {
-    println!("{}: {}", " - Max Backups".dimmed(), config.max_backups);
-  }
-
-  crate::command::wait_for_enter("start backup", yes)?;
-
-  let db = database::init(&config.database).await?;
-
-  database::utils::backup(&db, &config.backups_folder).await?;
-
-  // Early return if backup pruning disabled
-  if config.max_backups == 0 {
-    return Ok(());
-  }
-
-  // Know that new backup was taken successfully at this point,
-  // safe to prune old backup folders
-
-  prune_inner().await
-}
-
-async fn restore(
-  restore_folder: Option<&Path>,
-  index: bool,
-  yes: bool,
-) -> anyhow::Result<()> {
-  let config = cli_config();
-
-  println!(
-    "\n🦎  {} Database {} Utility  🦎",
-    "Komodo".bold(),
-    "Restore".purple().bold()
-  );
-  println!(
-    "\n{}\n",
-    " - Restores database contents from gzip compressed files."
-      .dimmed()
-  );
-  if let Some(uri) = optional_string(&config.database_target.uri) {
-    println!("{}: {}", " - Target URI".dimmed(), sanitize_uri(&uri));
-  }
-  if let Some(address) =
-    optional_string(&config.database_target.address)
-  {
-    println!("{}: {address}", " - Target Address".dimmed());
-  }
-  if let Some(username) =
-    optional_string(&config.database_target.username)
-  {
-    println!("{}: {username}", " - Target Username".dimmed());
-  }
-  println!(
-    "{}: {}",
-    " - Target Db Name".dimmed(),
-    config.database_target.db_name,
-  );
-  if !index {
-    println!(
-      "{}: {}",
-      " - Target Db Indexing".dimmed(),
-      "DISABLED".red(),
-    );
-  }
-  println!(
-    "\n{}: {:?}",
-    " - Backups Folder".dimmed(),
-    config.backups_folder
-  );
-  if let Some(restore_folder) = restore_folder {
-    println!("{}: {restore_folder:?}", " - Restore Folder".dimmed());
-  }
-
-  crate::command::wait_for_enter("start restore", yes)?;
-
-  let db = if index {
-    database::Client::new(&config.database_target).await?.db
-  } else {
-    database::init(&config.database_target).await?
-  };
-
-  database::utils::restore(
-    &db,
-    &config.backups_folder,
-    restore_folder,
-  )
-  .await
-}
-
-async fn prune(yes: bool) -> anyhow::Result<()> {
-  let config = cli_config();
-
-  println!(
-    "\n🦎  {} Database {} Utility  🦎",
-    "Komodo".bold(),
-    "Backup Prune".cyan().bold()
-  );
-  println!(
-    "\n{}\n",
-    " - Prunes database backup folders when greater than the configured amount."
-      .dimmed()
-  );
-  println!(
-    "{}: {:?}",
-    " - Backups Folder".dimmed(),
-    config.backups_folder
-  );
-  if config.max_backups == 0 {
-    println!(
-      "{}{}",
-      " - Backup pruning".dimmed(),
-      "disabled".red().dimmed()
-    );
-  } else {
-    println!("{}: {}", " - Max Backups".dimmed(), config.max_backups);
-  }
-
-  // Early return if backup pruning disabled
-  if config.max_backups == 0 {
-    info!(
-      "Backup pruning is disabled, enabled using 'max_backups' (KOMODO_CLI_MAX_BACKUPS)"
-    );
-    return Ok(());
-  }
-
-  crate::command::wait_for_enter("start backup prune", yes)?;
-
-  prune_inner().await
-}
-
-async fn prune_inner() -> anyhow::Result<()> {
-  let config = cli_config();
-
-  let mut backups_dir =
-    match tokio::fs::read_dir(&config.backups_folder)
-      .await
-      .context("Failed to read backups folder for prune")
-    {
-      Ok(backups_dir) => backups_dir,
-      Err(e) => {
-        warn!("{e:#}");
-        return Ok(());
-      }
-    };
-
-  let mut backup_folders = Vec::new();
-  loop {
-    match backups_dir.next_entry().await {
-      Ok(Some(entry)) => {
-        let Ok(metadata) = entry.metadata().await else {
-          continue;
-        };
-        if metadata.is_dir() {
-          backup_folders.push(entry.path());
-        }
-      }
-      Ok(None) => break,
-      Err(_) => {
-        continue;
-      }
-    }
-  }
-  // Ordered from oldest -> newest
-  backup_folders.sort();
-
-  let max_backups = config.max_backups as usize;
-  let backup_folders_len = backup_folders.len();
-
-  // Early return if under the backup count threshold
-  if backup_folders_len <= max_backups {
-    info!("No backups to prune");
-    return Ok(());
-  }
-
-  let to_delete =
-    &backup_folders[..(backup_folders_len - max_backups)];
-
-  info!("Pruning old backups: {to_delete:?}");
-
-  for path in to_delete {
-    if let Err(e) =
-      tokio::fs::remove_dir_all(path).await.with_context(|| {
-        format!("Failed to delete backup folder at {path:?}")
-      })
-    {
-      warn!("{e:#}");
-    }
-  }
-
-  Ok(())
-}
-
-async fn copy(index: bool, yes: bool) -> anyhow::Result<()> {
-  let config = cli_config();
-
-  println!(
-    "\n🦎  {} Database {} Utility  🦎",
-    "Komodo".bold(),
-    "Copy".blue().bold()
-  );
-  println!(
-    "\n{}\n",
-    " - Copies database contents to another database.".dimmed()
-  );
-
-  if let Some(uri) = optional_string(&config.database.uri) {
-    println!("{}: {}", " - Source URI".dimmed(), sanitize_uri(&uri));
-  }
-  if let Some(address) = optional_string(&config.database.address) {
-    println!("{}: {address}", " - Source Address".dimmed());
-  }
-  if let Some(username) = optional_string(&config.database.username) {
-    println!("{}: {username}", " - Source Username".dimmed());
-  }
-  println!(
-    "{}: {}\n",
-    " - Source Db Name".dimmed(),
-    config.database.db_name,
-  );
-
-  if let Some(uri) = optional_string(&config.database_target.uri) {
-    println!("{}: {}", " - Target URI".dimmed(), sanitize_uri(&uri));
-  }
-  if let Some(address) =
-    optional_string(&config.database_target.address)
-  {
-    println!("{}: {address}", " - Target Address".dimmed());
-  }
-  if let Some(username) =
-    optional_string(&config.database_target.username)
-  {
-    println!("{}: {username}", " - Target Username".dimmed());
-  }
-  println!(
-    "{}: {}",
-    " - Target Db Name".dimmed(),
-    config.database_target.db_name,
-  );
-  if !index {
-    println!(
-      "{}: {}",
-      " - Target Db Indexing".dimmed(),
-      "DISABLED".red(),
-    );
-  }
-
-  crate::command::wait_for_enter("start copy", yes)?;
-
-  let source_db = database::init(&config.database).await?;
-  let target_db = if index {
-    database::Client::new(&config.database_target).await?.db
-  } else {
-    database::init(&config.database_target).await?
-  };
-
-  database::utils::copy(&source_db, &target_db).await
-}
-
-async fn v1_downgrade(yes: bool) -> anyhow::Result<()> {
-  let config = cli_config();
-
-  println!(
-    "\n🦎  {} Database {}  🦎",
-    "Komodo".bold(),
-    "V1 Downgrade".purple().bold()
-  );
-  println!(
-    "\n{}\n",
-    " - Downgrade the database to V1 compatible data structures."
-      .dimmed()
-  );
-  if let Some(uri) = optional_string(&config.database.uri) {
-    println!("{}: {}", " - URI".dimmed(), sanitize_uri(&uri));
-  }
-  if let Some(address) = optional_string(&config.database.address) {
-    println!("{}: {address}", " - Address".dimmed());
-  }
-  if let Some(username) = optional_string(&config.database.username) {
-    println!("{}: {username}", " - Username".dimmed());
-  }
-  println!(
-    "{}: {}\n",
-    " - Db Name".dimmed(),
-    config.database.db_name,
-  );
-
-  crate::command::wait_for_enter("run downgrade", yes)?;
-
-  let db = database::init(&config.database).await?;
-
-  db.collection::<Document>("Server")
-    .update_many(doc! {}, doc! { "$set": { "info": null } })
-    .await
-    .context("Failed to downgrade Server schema")?;
-
-  db.collection::<Document>("Deployment")
-    .update_many(doc! {}, doc! { "$set": { "info": null } })
-    .await
-    .context("Failed to downgrade Deployment schema")?;
-
-  info!(
-    "V1 Downgrade complete. Ready to downgrade to komodo-core:1 ✅"
-  );
-
-  Ok(())
-}

bin/cli/src/command/execute.rs

@@ -1,232 +0,0 @@
-use std::time::Duration;
-
-use colored::Colorize;
-use futures_util::{StreamExt, stream::FuturesUnordered};
-use komodo_client::{
-  api::execute::{
-    BatchExecutionResponse, BatchExecutionResponseItem, Execution,
-  },
-  entities::{resource_link, update::Update},
-};
-
-use crate::config::cli_config;
-
-enum ExecutionResult {
-  Single(Box<Update>),
-  Batch(BatchExecutionResponse),
-}
-
-pub async fn handle(
-  execution: &Execution,
-  yes: bool,
-) -> anyhow::Result<()> {
-  if matches!(execution, Execution::None(_)) {
-    println!("Got 'none' execution. Doing nothing...");
-    tokio::time::sleep(Duration::from_secs(3)).await;
-    println!("Finished doing nothing. Exiting...");
-    std::process::exit(0);
-  }
-
-  println!("\n{}: Execution", "Mode".dimmed());
-
-  macro_rules! handle_execution {
-    (
-      execute: [$($ExecVariant:ident),* $(,)?],
-      batch: [$($BatchVariant:ident),* $(,)?],
-    ) => {{
-      // Print data
-      match execution {
-        $(Execution::$ExecVariant(data) => println!("{}: {data:?}", "Data".dimmed()),)*
-        $(Execution::$BatchVariant(data) => println!("{}: {data:?}", "Data".dimmed()),)*
-        Execution::CommitSync(data) => println!("{}: {data:?}", "Data".dimmed()),
-        Execution::Sleep(data) => println!("{}: {data:?}", "Data".dimmed()),
-        Execution::None(data) => println!("{}: {data:?}", "Data".dimmed()),
-      }
-
-      $crate::command::wait_for_enter("run execution", yes)?;
-
-      info!("Running Execution...");
-
-      let client = $crate::command::komodo_client().await?;
-
-      // Execute and get result
-      match execution.clone() {
-        $(
-          Execution::$ExecVariant(request) => client
-            .execute(request)
-            .await
-            .map(|u| ExecutionResult::Single(u.into())),
-        )*
-        $(
-          Execution::$BatchVariant(request) => {
-            client.execute(request).await.map(ExecutionResult::Batch)
-          }
-        )*
-        Execution::CommitSync(request) => client
-          .write(request)
-          .await
-          .map(|u| ExecutionResult::Single(u.into())),
-        Execution::Sleep(request) => {
-          let duration =
-            Duration::from_millis(request.duration_ms as u64);
-          tokio::time::sleep(duration).await;
-          println!("Finished sleeping!");
-          std::process::exit(0)
-        }
-        Execution::None(_) => unreachable!(),
-      }
-    }};
-  }
-
-  let res = handle_execution!(
-    execute: [
-      RunAction,
-      CancelAction,
-      RunProcedure,
-      CancelProcedure,
-      RunBuild,
-      CancelBuild,
-      Deploy,
-      PullDeployment,
-      StartDeployment,
-      RestartDeployment,
-      PauseDeployment,
-      UnpauseDeployment,
-      StopDeployment,
-      DestroyDeployment,
-      CloneRepo,
-      PullRepo,
-      BuildRepo,
-      CancelRepoBuild,
-      StartContainer,
-      RestartContainer,
-      PauseContainer,
-      UnpauseContainer,
-      StopContainer,
-      DestroyContainer,
-      StartAllContainers,
-      RestartAllContainers,
-      PauseAllContainers,
-      UnpauseAllContainers,
-      StopAllContainers,
-      PruneContainers,
-      DeleteNetwork,
-      PruneNetworks,
-      DeleteImage,
-      PruneImages,
-      DeleteVolume,
-      PruneVolumes,
-      PruneDockerBuilders,
-      PruneBuildx,
-      PruneSystem,
-      RunSync,
-      DeployStack,
-      DeployStackIfChanged,
-      PullStack,
-      StartStack,
-      RestartStack,
-      PauseStack,
-      UnpauseStack,
-      StopStack,
-      DestroyStack,
-      RunStackService,
-      TestAlerter,
-      SendAlert,
-      RemoveSwarmNodes,
-      UpdateSwarmNode,
-      RemoveSwarmStacks,
-      RemoveSwarmServices,
-      CreateSwarmConfig,
-      RotateSwarmConfig,
-      RemoveSwarmConfigs,
-      CreateSwarmSecret,
-      RotateSwarmSecret,
-      RemoveSwarmSecrets,
-      ClearRepoCache,
-      BackupCoreDatabase,
-      GlobalAutoUpdate,
-      RotateAllServerKeys,
-      RotateCoreKeys,
-    ],
-    batch: [
-      BatchRunAction,
-      BatchRunProcedure,
-      BatchRunBuild,
-      BatchDeploy,
-      BatchDestroyDeployment,
-      BatchCloneRepo,
-      BatchPullRepo,
-      BatchBuildRepo,
-      BatchDeployStack,
-      BatchDeployStackIfChanged,
-      BatchPullStack,
-      BatchDestroyStack,
-    ],
-  );
-
-  match res {
-    Ok(ExecutionResult::Single(update)) => {
-      poll_update_until_complete(&update).await
-    }
-    Ok(ExecutionResult::Batch(updates)) => {
-      let mut handles = updates
-        .iter()
-        .map(|update| async move {
-          match update {
-            BatchExecutionResponseItem::Ok(update) => {
-              poll_update_until_complete(update).await
-            }
-            BatchExecutionResponseItem::Err(e) => {
-              error!("{e:#?}");
-              Ok(())
-            }
-          }
-        })
-        .collect::<FuturesUnordered<_>>();
-      while let Some(res) = handles.next().await {
-        match res {
-          Ok(()) => {}
-          Err(e) => {
-            error!("{e:#?}");
-          }
-        }
-      }
-      Ok(())
-    }
-    Err(e) => {
-      error!("{e:#?}");
-      Ok(())
-    }
-  }
-}
-
-async fn poll_update_until_complete(
-  update: &Update,
-) -> anyhow::Result<()> {
-  let link = if update.id.is_empty() {
-    let (resource_type, id) = update.target.extract_variant_id();
-    resource_link(&cli_config().host, resource_type, id)
-  } else {
-    format!("{}/updates/{}", cli_config().host, update.id)
-  };
-  println!("Link: '{}'", link.bold());
-
-  let client = super::komodo_client().await?;
-
-  let timer = tokio::time::Instant::now();
-  let update = client.poll_update_until_complete(&update.id).await?;
-  if update.success {
-    println!(
-      "FINISHED in {}: {}",
-      format!("{:.1?}", timer.elapsed()).bold(),
-      "EXECUTION SUCCESSFUL".green(),
-    );
-  } else {
-    eprintln!(
-      "FINISHED in {}: {}",
-      format!("{:.1?}", timer.elapsed()).bold(),
-      "EXECUTION FAILED".red(),
-    );
-  }
-  Ok(())
-}

bin/cli/src/command/mod.rs

@@ -1,184 +0,0 @@
-use std::io::Read;
-
-use anyhow::{Context, anyhow};
-use chrono::TimeZone;
-use colored::Colorize;
-use comfy_table::{Attribute, Cell, Table};
-use komodo_client::{
-  KomodoClient,
-  entities::config::cli::{CliTableBorders, args::CliFormat},
-};
-use serde::Serialize;
-use tokio::sync::OnceCell;
-use wildcard::Wildcard;
-
-use crate::config::cli_config;
-
-pub mod container;
-pub mod core_info;
-pub mod create;
-pub mod database;
-pub mod execute;
-pub mod list;
-pub mod terminal;
-pub mod update;
-
-async fn komodo_client() -> anyhow::Result<&'static KomodoClient> {
-  static KOMODO_CLIENT: OnceCell<KomodoClient> =
-    OnceCell::const_new();
-  KOMODO_CLIENT
-    .get_or_try_init(|| async {
-      let config = cli_config();
-      let (Some(key), Some(secret)) =
-        (&config.cli_key, &config.cli_secret)
-      else {
-        return Err(anyhow!(
-          "Must provide both cli_key and cli_secret"
-        ));
-      };
-      KomodoClient::new(&config.host, key, secret)
-        .with_healthcheck()
-        .await
-    })
-    .await
-}
-
-fn wait_for_enter(
-  press_enter_to: &str,
-  skip: bool,
-) -> anyhow::Result<()> {
-  if skip {
-    println!();
-    return Ok(());
-  }
-  println!(
-    "\nPress {} to {}\n",
-    "ENTER".green(),
-    press_enter_to.bold()
-  );
-  let buffer = &mut [0u8];
-  std::io::stdin()
-    .read_exact(buffer)
-    .context("failed to read ENTER")?;
-  Ok(())
-}
-
-/// Sanitizes uris of the form:
-/// `protocol://username:password@address`
-fn sanitize_uri(uri: &str) -> String {
-  // protocol: `mongodb`
-  // credentials_address: `username:password@address`
-  let Some((protocol, credentials_address)) = uri.split_once("://")
-  else {
-    // If no protocol, return as-is
-    return uri.to_string();
-  };
-
-  // credentials: `username:password`
-  let Some((credentials, address)) =
-    credentials_address.split_once('@')
-  else {
-    // If no credentials, return as-is
-    return uri.to_string();
-  };
-
-  match credentials.split_once(':') {
-    Some((username, _)) => {
-      format!("{protocol}://{username}:*****@{address}")
-    }
-    None => {
-      format!("{protocol}://*****@{address}")
-    }
-  }
-}
-
-fn print_items<T: PrintTable + Serialize>(
-  items: Vec<T>,
-  format: CliFormat,
-  links: bool,
-) -> anyhow::Result<()> {
-  match format {
-    CliFormat::Table => {
-      let mut table = Table::new();
-      let preset = {
-        use comfy_table::presets::*;
-        match cli_config().table_borders {
-          None | Some(CliTableBorders::Horizontal) => {
-            UTF8_HORIZONTAL_ONLY
-          }
-          Some(CliTableBorders::Vertical) => UTF8_FULL_CONDENSED,
-          Some(CliTableBorders::Inside) => UTF8_NO_BORDERS,
-          Some(CliTableBorders::Outside) => UTF8_BORDERS_ONLY,
-          Some(CliTableBorders::All) => UTF8_FULL,
-        }
-      };
-      table.load_preset(preset).set_header(
-        T::header(links)
-          .iter()
-          .map(|h| Cell::new(h).add_attribute(Attribute::Bold)),
-      );
-      for item in items {
-        table.add_row(item.row(links));
-      }
-      println!("{table}");
-    }
-    CliFormat::Json => {
-      println!(
-        "{}",
-        serde_json::to_string_pretty(&items)
-          .context("Failed to serialize items to JSON")?
-      );
-    }
-  }
-  Ok(())
-}
-
-trait PrintTable {
-  fn header(links: bool) -> &'static [&'static str];
-  fn row(self, links: bool) -> Vec<Cell>;
-}
-
-fn parse_wildcards(items: &[String]) -> Vec<Wildcard<'_>> {
-  items
-    .iter()
-    .flat_map(|i| {
-      Wildcard::new(i.as_bytes()).inspect_err(|e| {
-        warn!("Failed to parse wildcard: {i} | {e:?}")
-      })
-    })
-    .collect::<Vec<_>>()
-}
-
-fn matches_wildcards(
-  wildcards: &[Wildcard<'_>],
-  items: &[&str],
-) -> bool {
-  if wildcards.is_empty() {
-    return true;
-  }
-  items.iter().any(|item| {
-    wildcards.iter().any(|wc| wc.is_match(item.as_bytes()))
-  })
-}
-
-fn format_timetamp(ts: i64) -> anyhow::Result<String> {
-  let ts = chrono::Local
-    .timestamp_millis_opt(ts)
-    .single()
-    .context("Invalid ts")?
-    .format("%m/%d %H:%M:%S")
-    .to_string();
-  Ok(ts)
-}
-
-fn clamp_sha(maybe_sha: &str) -> String {
-  if maybe_sha.starts_with("sha256:") {
-    maybe_sha[0..20].to_string() + "..."
-  } else {
-    maybe_sha.to_string()
-  }
-}
-
-// fn text_link(link: &str, text: &str) -> String {
-//   format!("\x1b]8;;{link}\x07{text}\x1b]8;;\x07")
-// }

bin/cli/src/command/terminal.rs

@@ -1,389 +0,0 @@
-use anyhow::{Context, anyhow};
-use colored::Colorize;
-use komodo_client::{
-  api::{
-    read::{GetServer, ListAllContainers, ListServers},
-    terminal::InitTerminal,
-  },
-  entities::{
-    config::cli::args::terminal::{Attach, Connect, Exec},
-    server::ServerQuery,
-    terminal::{
-      ContainerTerminalMode, TerminalRecreateMode,
-      TerminalResizeMessage, TerminalStdinMessage,
-    },
-  },
-  ws::terminal::TerminalWebsocket,
-};
-use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
-use tokio_util::sync::CancellationToken;
-
-pub async fn handle_connect(
-  Connect {
-    server,
-    name,
-    command,
-    recreate,
-  }: &Connect,
-) -> anyhow::Result<()> {
-  handle_terminal_forwarding(server, async {
-    super::komodo_client()
-      .await?
-      .connect_server_terminal(
-        server.to_string(),
-        Some(name.to_string()),
-        Some(InitTerminal {
-          command: command.clone(),
-          recreate: if *recreate {
-            TerminalRecreateMode::Always
-          } else {
-            TerminalRecreateMode::DifferentCommand
-          },
-          mode: None,
-        }),
-      )
-      .await
-  })
-  .await
-}
-
-pub async fn handle_exec(
-  Exec {
-    server,
-    container,
-    shell,
-    recreate,
-  }: &Exec,
-) -> anyhow::Result<()> {
-  let server = get_server(server.clone(), container).await?;
-  handle_terminal_forwarding(
-    &format!("{server}/{container}"),
-    async {
-      super::komodo_client()
-        .await?
-        .connect_container_terminal(
-          server,
-          container.to_string(),
-          None,
-          Some(InitTerminal {
-            command: Some(shell.to_string()),
-            recreate: if *recreate {
-              TerminalRecreateMode::Always
-            } else {
-              TerminalRecreateMode::DifferentCommand
-            },
-            mode: Some(ContainerTerminalMode::Exec),
-          }),
-        )
-        .await
-    },
-  )
-  .await
-}
-
-pub async fn handle_attach(
-  Attach {
-    server,
-    container,
-    recreate,
-  }: &Attach,
-) -> anyhow::Result<()> {
-  let server = get_server(server.clone(), container).await?;
-  handle_terminal_forwarding(
-    &format!("{server}/{container}-attach"),
-    async {
-      super::komodo_client()
-        .await?
-        .connect_container_terminal(
-          server,
-          container.to_string(),
-          None,
-          Some(InitTerminal {
-            command: None,
-            recreate: if *recreate {
-              TerminalRecreateMode::Always
-            } else {
-              TerminalRecreateMode::DifferentCommand
-            },
-            mode: Some(ContainerTerminalMode::Attach),
-          }),
-        )
-        .await
-    },
-  )
-  .await
-}
-
-async fn get_server(
-  server: Option<String>,
-  container: &str,
-) -> anyhow::Result<String> {
-  // Don't need to find server for terminal,
-  // user provided it, early return.
-  if let Some(server) = server {
-    return Ok(server);
-  }
-
-  let client = super::komodo_client().await?;
-
-  let mut containers = client
-    .read(ListAllContainers {
-      servers: Default::default(),
-      tags: Default::default(),
-      terms: vec![container.to_string()],
-      state: Default::default(),
-      limit: Some(0),
-      page: 0,
-      sort_by: Default::default(),
-      sort_desc: false,
-    })
-    .await?;
-
-  if containers.is_empty() {
-    return Err(anyhow!(
-      "Did not find any container matching {container}"
-    ));
-  }
-
-  if containers.len() == 1 {
-    let server_id = containers
-      .pop()
-      .context("Shouldn't happen")?
-      .server_id
-      .context("Container doesn't have server_id")?;
-    let server_name =
-      client.read(GetServer { server: server_id }).await?.name;
-    return Ok(server_name);
-  }
-
-  let servers = containers
-    .into_iter()
-    .flat_map(|container| container.server_id)
-    .collect::<Vec<_>>();
-
-  let servers = client
-    .read(ListServers {
-      query: ServerQuery::builder().names(servers).build(),
-      limit: Some(0),
-      ..Default::default()
-    })
-    .await?
-    .into_iter()
-    .map(|server| format!("\t- {}", server.name.bold()))
-    .collect::<Vec<_>>()
-    .join("\n");
-
-  Err(anyhow!(
-    "Multiple containers matching '{}' on Servers:\n{servers}",
-    container.bold(),
-  ))
-}
-
-async fn handle_terminal_forwarding<
-  C: Future<Output = anyhow::Result<TerminalWebsocket>>,
->(
-  label: &str,
-  connect: C,
-) -> anyhow::Result<()> {
-  // Need to forward multiple sources into ws write
-  let (write_tx, mut write_rx) =
-    tokio::sync::mpsc::channel::<TerminalStdinMessage>(1024);
-
-  // ================
-  //  SETUP RESIZING
-  // ================
-
-  // Subscribe to SIGWINCH for resize messages
-  let mut sigwinch = tokio::signal::unix::signal(
-    tokio::signal::unix::SignalKind::window_change(),
-  )
-  .context("failed to register SIGWINCH handler")?;
-
-  // Send first resize messsage, bailing if it fails to get the size.
-  write_tx.send(resize_message()?).await?;
-
-  let cancel = CancellationToken::new();
-
-  let forward_resize = async {
-    while future_or_cancel(sigwinch.recv(), &cancel)
-      .await
-      .flatten()
-      .is_some()
-    {
-      if let Ok(resize_message) = resize_message()
-        && write_tx.send(resize_message).await.is_err()
-      {
-        break;
-      }
-    }
-    cancel.cancel();
-  };
-
-  let forward_stdin = async {
-    let mut stdin = tokio::io::stdin();
-    let mut buf = [0u8; 8192];
-    while let Some(Ok(n)) =
-      future_or_cancel(stdin.read(&mut buf), &cancel).await
-    {
-      // EOF
-      if n == 0 {
-        break;
-      }
-      let bytes = &buf[..n];
-      // Check for disconnect sequence (alt + q)
-      if bytes == [197, 147] {
-        break;
-      }
-      // Forward bytes
-      if write_tx
-        .send(TerminalStdinMessage::Forward(bytes.to_vec()))
-        .await
-        .is_err()
-      {
-        break;
-      };
-    }
-    cancel.cancel();
-  };
-
-  // =====================
-  //  CONNECT AND FORWARD
-  // =====================
-
-  let (mut ws_write, mut ws_read) = connect.await?.split();
-
-  let forward_write = async {
-    while let Some(message) =
-      future_or_cancel(write_rx.recv(), &cancel).await.flatten()
-    {
-      if let Err(e) = ws_write.send_stdin_message(message).await {
-        cancel.cancel();
-        return Some(e);
-      };
-    }
-    cancel.cancel();
-    None
-  };
-
-  let forward_read = async {
-    let mut stdout = tokio::io::stdout();
-
-    // Write connection message
-    if let Err(e) = write_connection_message(&mut stdout, label)
-      .await
-      .context("Failed to write text to stdout")
-    {
-      cancel.cancel();
-      return Some(e);
-    }
-
-    while let Some(msg) =
-      future_or_cancel(ws_read.receive_stdout(), &cancel).await
-    {
-      let bytes = match msg {
-        Ok(Some(bytes)) => bytes,
-        Ok(None) => break,
-        Err(e) => {
-          cancel.cancel();
-          return Some(e.context("Websocket read error"));
-        }
-      };
-      if let Err(e) = stdout
-        .write_all(&bytes)
-        .await
-        .context("Failed to write text to stdout")
-      {
-        cancel.cancel();
-        return Some(e);
-      }
-      let _ = stdout.flush().await;
-    }
-    cancel.cancel();
-    None
-  };
-
-  let guard = RawModeGuard::enable_raw_mode()?;
-
-  let (_, _, write_error, read_error) = tokio::join!(
-    forward_resize,
-    forward_stdin,
-    forward_write,
-    forward_read
-  );
-
-  drop(guard);
-
-  if let Some(e) = write_error {
-    eprintln!("\nFailed to forward stdin | {e:#}");
-  }
-
-  if let Some(e) = read_error {
-    eprintln!("\nFailed to forward stdout | {e:#}");
-  }
-
-  println!("\n\n{} {}", "connection".bold(), "closed".red().bold());
-
-  // It doesn't seem to exit by itself after the raw mode stuff.
-  std::process::exit(0)
-}
-
-async fn write_connection_message(
-  stdout: &mut tokio::io::Stdout,
-  label: &str,
-) -> anyhow::Result<()> {
-  // Use message without ansi for correct length
-  let message_clean = format!("# Connected to {label} (km) #");
-  let bounder = "=".repeat(message_clean.chars().count());
-
-  let message = format!(
-    "# {} to {} {} #",
-    "Connected".green().bold(),
-    label.bold(),
-    "(km)".dimmed()
-  );
-
-  stdout
-    .write_all(
-      format!("\n{bounder}\r\n{message}\r\n{bounder}\r\n").as_bytes(),
-    )
-    .await?;
-  let _ = stdout.flush().await;
-
-  Ok(())
-}
-
-fn resize_message() -> anyhow::Result<TerminalStdinMessage> {
-  let (cols, rows) = crossterm::terminal::size()
-    .context("Failed to get terminal size")?;
-  Ok(TerminalStdinMessage::Resize(TerminalResizeMessage {
-    rows,
-    cols,
-  }))
-}
-
-struct RawModeGuard;
-
-impl RawModeGuard {
-  fn enable_raw_mode() -> anyhow::Result<Self> {
-    crossterm::terminal::enable_raw_mode()
-      .context("Failed to enable terminal raw mode")?;
-    Ok(Self)
-  }
-}
-impl Drop for RawModeGuard {
-  fn drop(&mut self) {
-    if let Err(e) = crossterm::terminal::disable_raw_mode() {
-      eprintln!("Failed to disable terminal raw mode | {e:?}");
-    }
-  }
-}
-
-async fn future_or_cancel<T, F: Future<Output = T>>(
-  fut: F,
-  cancel: &CancellationToken,
-) -> Option<T> {
-  tokio::select! {
-    res = fut => Some(res),
-    _ = cancel.cancelled() => None
-  }
-}

bin/cli/src/command/update/mod.rs

@@ -1,43 +0,0 @@
-use komodo_client::entities::{
-  build::PartialBuildConfig,
-  config::cli::args::update::UpdateCommand,
-  deployment::PartialDeploymentConfig, repo::PartialRepoConfig,
-  server::PartialServerConfig, stack::PartialStackConfig,
-  sync::PartialResourceSyncConfig,
-};
-
-mod resource;
-mod user;
-mod variable;
-
-pub async fn handle(command: &UpdateCommand) -> anyhow::Result<()> {
-  match command {
-    UpdateCommand::Build(update) => {
-      resource::update::<PartialBuildConfig>(update).await
-    }
-    UpdateCommand::Deployment(update) => {
-      resource::update::<PartialDeploymentConfig>(update).await
-    }
-    UpdateCommand::Repo(update) => {
-      resource::update::<PartialRepoConfig>(update).await
-    }
-    UpdateCommand::Server(update) => {
-      resource::update::<PartialServerConfig>(update).await
-    }
-    UpdateCommand::Stack(update) => {
-      resource::update::<PartialStackConfig>(update).await
-    }
-    UpdateCommand::Sync(update) => {
-      resource::update::<PartialResourceSyncConfig>(update).await
-    }
-    UpdateCommand::Variable {
-      name,
-      value,
-      secret,
-      yes,
-    } => variable::update(name, value, *secret, *yes).await,
-    UpdateCommand::User { username, command } => {
-      user::update(username, command).await
-    }
-  }
-}

bin/cli/src/command/update/resource.rs

@@ -1,152 +0,0 @@
-use anyhow::Context;
-use colored::Colorize;
-use komodo_client::{
-  api::write::{
-    UpdateBuild, UpdateDeployment, UpdateRepo, UpdateResourceSync,
-    UpdateServer, UpdateStack,
-  },
-  entities::{
-    build::PartialBuildConfig,
-    config::cli::args::update::UpdateResource,
-    deployment::PartialDeploymentConfig, repo::PartialRepoConfig,
-    server::PartialServerConfig, stack::PartialStackConfig,
-    sync::PartialResourceSyncConfig,
-  },
-};
-use serde::{Serialize, de::DeserializeOwned};
-
-pub async fn update<
-  T: std::fmt::Debug + Serialize + DeserializeOwned + ResourceUpdate,
->(
-  UpdateResource {
-    resource,
-    update,
-    yes,
-  }: &UpdateResource,
-) -> anyhow::Result<()> {
-  println!("\n{}: Update {}\n", "Mode".dimmed(), T::resource_type());
-  println!(" - {}: {resource}", "Name".dimmed());
-
-  let config = serde_qs::from_str::<T>(update)
-    .context("Failed to deserialize config")?;
-
-  match serde_json::to_string_pretty(&config) {
-    Ok(config) => {
-      println!(" - {}: {config}", "Update".dimmed());
-    }
-    Err(_) => {
-      println!(" - {}: {config:#?}", "Update".dimmed());
-    }
-  }
-
-  crate::command::wait_for_enter("update resource", *yes)?;
-
-  config.apply(resource).await
-}
-
-pub trait ResourceUpdate {
-  fn resource_type() -> &'static str;
-  async fn apply(self, resource: &str) -> anyhow::Result<()>;
-}
-
-impl ResourceUpdate for PartialBuildConfig {
-  fn resource_type() -> &'static str {
-    "Build"
-  }
-  async fn apply(self, resource: &str) -> anyhow::Result<()> {
-    let client = crate::command::komodo_client().await?;
-    client
-      .write(UpdateBuild {
-        id: resource.to_string(),
-        config: self,
-      })
-      .await
-      .context("Failed to update build config")?;
-    Ok(())
-  }
-}
-
-impl ResourceUpdate for PartialDeploymentConfig {
-  fn resource_type() -> &'static str {
-    "Deployment"
-  }
-  async fn apply(self, resource: &str) -> anyhow::Result<()> {
-    let client = crate::command::komodo_client().await?;
-    client
-      .write(UpdateDeployment {
-        id: resource.to_string(),
-        config: self,
-      })
-      .await
-      .context("Failed to update deployment config")?;
-    Ok(())
-  }
-}
-
-impl ResourceUpdate for PartialRepoConfig {
-  fn resource_type() -> &'static str {
-    "Repo"
-  }
-  async fn apply(self, resource: &str) -> anyhow::Result<()> {
-    let client = crate::command::komodo_client().await?;
-    client
-      .write(UpdateRepo {
-        id: resource.to_string(),
-        config: self,
-      })
-      .await
-      .context("Failed to update repo config")?;
-    Ok(())
-  }
-}
-
-impl ResourceUpdate for PartialServerConfig {
-  fn resource_type() -> &'static str {
-    "Server"
-  }
-  async fn apply(self, resource: &str) -> anyhow::Result<()> {
-    let client = crate::command::komodo_client().await?;
-    client
-      .write(UpdateServer {
-        id: resource.to_string(),
-        config: self,
-      })
-      .await
-      .context("Failed to update server config")?;
-    Ok(())
-  }
-}
-
-impl ResourceUpdate for PartialStackConfig {
-  fn resource_type() -> &'static str {
-    "Stack"
-  }
-  async fn apply(self, resource: &str) -> anyhow::Result<()> {
-    let client = crate::command::komodo_client().await?;
-    client
-      .write(UpdateStack {
-        id: resource.to_string(),
-        config: self,
-      })
-      .await
-      .context("Failed to update stack config")?;
-    Ok(())
-  }
-}
-
-impl ResourceUpdate for PartialResourceSyncConfig {
-  fn resource_type() -> &'static str {
-    "Sync"
-  }
-  async fn apply(self, resource: &str) -> anyhow::Result<()> {
-    let client = crate::command::komodo_client().await?;
-    client
-      .write(UpdateResourceSync {
-        id: resource.to_string(),
-        config: self,
-      })
-      .await
-      .context("Failed to update sync config")?;
-    Ok(())
-  }
-}

bin/cli/src/command/update/user.rs

@@ -1,142 +0,0 @@
-use anyhow::Context;
-use colored::Colorize;
-use database::mungos::mongodb::bson::doc;
-use komodo_client::entities::{
-  config::{
-    cli::args::{CliEnabled, update::UpdateUserCommand},
-    empty_or_redacted,
-  },
-  optional_string,
-};
-
-use crate::{command::sanitize_uri, config::cli_config};
-
-pub async fn update(
-  username: &str,
-  command: &UpdateUserCommand,
-) -> anyhow::Result<()> {
-  match command {
-    UpdateUserCommand::Password {
-      password,
-      unsanitized,
-      yes,
-    } => {
-      update_password(username, password, *unsanitized, *yes).await
-    }
-    UpdateUserCommand::SuperAdmin { enabled, yes } => {
-      update_super_admin(username, *enabled, *yes).await
-    }
-    UpdateUserCommand::Clear2fa { yes } => {
-      clear_2fa(username, *yes).await
-    }
-  }
-}
-
-async fn update_password(
-  username: &str,
-  password: &str,
-  unsanitized: bool,
-  yes: bool,
-) -> anyhow::Result<()> {
-  println!("\n{}: Update Password\n", "Mode".dimmed());
-  println!(" - {}: {username}", "Username".dimmed());
-  if unsanitized {
-    println!(" - {}: {password}", "Password".dimmed());
-  } else {
-    println!(
-      " - {}: {}",
-      "Password".dimmed(),
-      empty_or_redacted(password)
-    );
-  }
-
-  crate::command::wait_for_enter("update password", yes)?;
-
-  info!("Updating password...");
-
-  let db = database::Client::new(&cli_config().database).await?;
-
-  let user = db
-    .users
-    .find_one(doc! { "username": username })
-    .await
-    .context("Failed to query database for user")?
-    .context("No user found with given username")?;
-
-  db.set_user_password(&user, password).await?;
-
-  info!("Password updated ✅");
-
-  Ok(())
-}
-
-async fn update_super_admin(
-  username: &str,
-  super_admin: CliEnabled,
-  yes: bool,
-) -> anyhow::Result<()> {
-  let config = cli_config();
-
-  println!("\n{}: Update Super Admin\n", "Mode".dimmed());
-  println!(" - {}: {username}", "Username".dimmed());
-  println!(" - {}: {super_admin}\n", "Super Admin".dimmed());
-
-  if let Some(uri) = optional_string(&config.database.uri) {
-    println!("{}: {}", " - Source URI".dimmed(), sanitize_uri(&uri));
-  }
-  if let Some(address) = optional_string(&config.database.address) {
-    println!("{}: {address}", " - Source Address".dimmed());
-  }
-  if let Some(username) = optional_string(&config.database.username) {
-    println!("{}: {username}", " - Source Username".dimmed());
-  }
-  println!(
-    "{}: {}",
-    " - Source Db Name".dimmed(),
-    config.database.db_name,
-  );
-
-  crate::command::wait_for_enter("update super admin", yes)?;
-
-  info!("Updating super admin...");
-
-  let db = database::Client::new(&config.database).await?;
-
-  // Make sure the user exists first before saying it is successful.
-  let user = db
-    .users
-    .find_one(doc! { "username": username })
-    .await
-    .context("Failed to query database for user")?
-    .context("No user found with given username")?;
-
-  let super_admin: bool = super_admin.into();
-  db.users
-    .update_one(
-      doc! { "username": user.username },
-      doc! { "$set": { "super_admin": super_admin } },
-    )
-    .await
-    .context("Failed to update user super admin on db")?;
-
-  info!("Super admin updated ✅");
-
-  Ok(())
-}
-
-async fn clear_2fa(username: &str, yes: bool) -> anyhow::Result<()> {
-  println!("\n{}: Clear 2FA Methods\n", "Mode".dimmed());
-  println!(" - {}: {username}", "Username".dimmed());
-
-  crate::command::wait_for_enter("clear user 2FA methods", yes)?;
-
-  info!("Clearing 2FA methods...");
-
-  let db = database::Client::new(&cli_config().database).await?;
-
-  db.clear_user_2fa_methods(username).await?;
-
-  info!("2FA methods cleared ✅");
-
-  Ok(())
-}

bin/cli/src/command/update/variable.rs

@@ -1,70 +0,0 @@
-use anyhow::Context;
-use colored::Colorize;
-use komodo_client::api::{
-  read::GetVariable,
-  write::{
-    CreateVariable, UpdateVariableIsSecret, UpdateVariableValue,
-  },
-};
-
-pub async fn update(
-  name: &str,
-  value: &str,
-  secret: Option<bool>,
-  yes: bool,
-) -> anyhow::Result<()> {
-  println!("\n{}: Update Variable\n", "Mode".dimmed());
-  println!(" - {}:  {name}", "Name".dimmed());
-  println!(" - {}: {value}", "Value".dimmed());
-  if let Some(secret) = secret {
-    println!(" - {}: {secret}", "Is Secret".dimmed());
-  }
-
-  crate::command::wait_for_enter("update variable", yes)?;
-
-  let client = crate::command::komodo_client().await?;
-
-  let Ok(existing) = client
-    .read(GetVariable {
-      name: name.to_string(),
-    })
-    .await
-  else {
-    // Create the variable
-    client
-      .write(CreateVariable {
-        name: name.to_string(),
-        value: value.to_string(),
-        is_secret: secret.unwrap_or_default(),
-        description: Default::default(),
-      })
-      .await
-      .context("Failed to create variable")?;
-    info!("Variable created ✅");
-    return Ok(());
-  };
-
-  client
-    .write(UpdateVariableValue {
-      name: name.to_string(),
-      value: value.to_string(),
-    })
-    .await
-    .context("Failed to update variable 'value'")?;
-  info!("Variable 'value' updated ✅");
-
-  let Some(secret) = secret else { return Ok(()) };
-
-  if secret != existing.is_secret {
-    client
-      .write(UpdateVariableIsSecret {
-        name: name.to_string(),
-        is_secret: secret,
-      })
-      .await
-      .context("Failed to update variable 'is_secret'")?;
-    info!("Variable 'is_secret' updated to {secret} ✅");
-  }
-
-  Ok(())
-}

bin/cli/src/config.rs

@@ -1,283 +0,0 @@
-use std::{path::PathBuf, sync::OnceLock};
-
-use anyhow::Context;
-use clap::Parser;
-use colored::Colorize;
-use komodo_client::entities::{
-  config::{
-    DatabaseConfig,
-    cli::{
-      CliConfig, Env,
-      args::{CliArgs, Command, Execute, database::DatabaseCommand},
-    },
-  },
-  logger::LogConfig,
-};
-use mogh_secret_file::maybe_read_item_from_file;
-
-pub fn cli_args() -> &'static CliArgs {
-  static CLI_ARGS: OnceLock<CliArgs> = OnceLock::new();
-  CLI_ARGS.get_or_init(CliArgs::parse)
-}
-
-pub fn cli_env() -> &'static Env {
-  static CLI_ARGS: OnceLock<Env> = OnceLock::new();
-  CLI_ARGS.get_or_init(|| {
-    match envy::from_env()
-      .context("Failed to parse Komodo CLI environment")
-    {
-      Ok(env) => env,
-      Err(e) => {
-        panic!("{e:?}")
-      }
-    }
-  })
-}
-
-pub fn cli_config() -> &'static CliConfig {
-  static CLI_CONFIG: OnceLock<CliConfig> = OnceLock::new();
-  CLI_CONFIG.get_or_init(|| {
-    let args = cli_args();
-    let env = cli_env().clone();
-    let config_paths = args
-      .config_path
-      .clone()
-      .unwrap_or(env.komodo_cli_config_paths);
-    let debug_startup =
-      args.debug_startup.unwrap_or(env.komodo_cli_debug_startup);
-
-    if debug_startup {
-      println!(
-        "{}: Komodo CLI version: {}",
-        "DEBUG".cyan(),
-        env!("CARGO_PKG_VERSION").blue().bold()
-      );
-      println!(
-        "{}: {}: {config_paths:?}",
-        "DEBUG".cyan(),
-        "Config Paths".dimmed(),
-      );
-    }
-
-    let config_keywords = args
-      .config_keyword
-      .clone()
-      .unwrap_or(env.komodo_cli_config_keywords);
-    let config_keywords = config_keywords
-      .iter()
-      .map(String::as_str)
-      .collect::<Vec<_>>();
-    if debug_startup {
-      println!(
-        "{}: {}: {config_keywords:?}",
-        "DEBUG".cyan(),
-        "Config File Keywords".dimmed(),
-      );
-    }
-    let mut unparsed_config = (mogh_config::ConfigLoader {
-      paths: &config_paths
-        .iter()
-        .map(PathBuf::as_path)
-        .collect::<Vec<_>>(),
-      match_wildcards: &config_keywords,
-      include_file_name: ".kminclude",
-      merge_nested: env.komodo_cli_merge_nested_config,
-      extend_array: env.komodo_cli_extend_config_arrays,
-      debug_print: debug_startup,
-    })
-    .load::<serde_json::Map<String, serde_json::Value>>()
-    .expect("failed at parsing config from paths");
-    let init_parsed_config = serde_json::from_value::<CliConfig>(
-      serde_json::Value::Object(unparsed_config.clone()),
-    )
-    .context("Failed to parse config")
-    .unwrap();
-
-    let (host, key, secret) = match &args.command {
-      Command::Execute(Execute {
-        host, key, secret, ..
-      }) => (host.clone(), key.clone(), secret.clone()),
-      _ => (None, None, None),
-    };
-
-    let backups_folder = match &args.command {
-      Command::Database {
-        command: DatabaseCommand::Backup { backups_folder, .. },
-      } => backups_folder.clone(),
-      Command::Database {
-        command: DatabaseCommand::Restore { backups_folder, .. },
-      } => backups_folder.clone(),
-      _ => None,
-    };
-    let (uri, address, username, password, db_name) =
-      match &args.command {
-        Command::Database {
-          command:
-            DatabaseCommand::Copy {
-              uri,
-              address,
-              username,
-              password,
-              db_name,
-              ..
-            },
-        } => (
-          uri.clone(),
-          address.clone(),
-          username.clone(),
-          password.clone(),
-          db_name.clone(),
-        ),
-        _ => (None, None, None, None, None),
-      };
-
-    let profile = args
-      .profile
-      .as_ref()
-      .or(init_parsed_config.default_profile.as_ref());
-
-    let unparsed_config = if let Some(profile) = profile
-      && !profile.is_empty()
-    {
-      // Find the profile config,
-      // then merge it with the Default config.
-      let serde_json::Value::Array(profiles) = unparsed_config
-        .remove("profile")
-        .context("Config has no profiles, but a profile is required")
-        .unwrap()
-      else {
-        panic!("`config.profile` is not array");
-      };
-      let Some(profile_config) = profiles.into_iter().find(|p| {
-        let Ok(parsed) =
-          serde_json::from_value::<CliConfig>(p.clone())
-        else {
-          return false;
-        };
-        &parsed.config_profile == profile
-          || parsed
-            .config_aliases
-            .iter()
-            .any(|alias| alias == profile)
-      }) else {
-        panic!("No profile matching '{profile}' was found.");
-      };
-      let serde_json::Value::Object(profile_config) = profile_config
-      else {
-        panic!("Profile config is not Object type.");
-      };
-      mogh_config::merge_config(
-        unparsed_config,
-        profile_config.clone(),
-        env.komodo_cli_merge_nested_config,
-        env.komodo_cli_extend_config_arrays,
-      )
-      .unwrap_or(profile_config)
-    } else {
-      unparsed_config
-    };
-    let config = serde_json::from_value::<CliConfig>(
-      serde_json::Value::Object(unparsed_config),
-    )
-    .context("Failed to parse final config")
-    .unwrap();
-    let config_profile = if config.config_profile.is_empty() {
-      String::from("None")
-    } else {
-      config.config_profile
-    };
-
-    CliConfig {
-      config_profile,
-      config_aliases: config.config_aliases,
-      default_profile: config.default_profile,
-      table_borders: env
-        .komodo_cli_table_borders
-        .or(config.table_borders),
-      host: host
-        .or(env.komodo_cli_host)
-        .or(env.komodo_host)
-        .unwrap_or(config.host),
-      cli_key: key.or(env.komodo_cli_key).or(config.cli_key),
-      cli_secret: secret
-        .or(env.komodo_cli_secret)
-        .or(config.cli_secret),
-      backups_folder: backups_folder
-        .or(env.komodo_cli_backups_folder)
-        .unwrap_or(config.backups_folder),
-      max_backups: env
-        .komodo_cli_max_backups
-        .unwrap_or(config.max_backups),
-      database_target: DatabaseConfig {
-        uri: uri
-          .or(env.komodo_cli_database_target_uri)
-          .unwrap_or(config.database_target.uri),
-        address: address
-          .or(env.komodo_cli_database_target_address)
-          .unwrap_or(config.database_target.address),
-        username: username
-          .or(env.komodo_cli_database_target_username)
-          .unwrap_or(config.database_target.username),
-        password: password
-          .or(env.komodo_cli_database_target_password)
-          .unwrap_or(config.database_target.password),
-        db_name: db_name
-          .or(env.komodo_cli_database_target_db_name)
-          .unwrap_or(config.database_target.db_name),
-        app_name: config.database_target.app_name,
-      },
-      database: DatabaseConfig {
-        uri: maybe_read_item_from_file(
-          env.komodo_database_uri_file,
-          env.komodo_database_uri,
-        )
-        .unwrap_or(config.database.uri),
-        address: env
-          .komodo_database_address
-          .unwrap_or(config.database.address),
-        username: maybe_read_item_from_file(
-          env.komodo_database_username_file,
-          env.komodo_database_username,
-        )
-        .unwrap_or(config.database.username),
-        password: maybe_read_item_from_file(
-          env.komodo_database_password_file,
-          env.komodo_database_password,
-        )
-        .unwrap_or(config.database.password),
-        db_name: env
-          .komodo_database_db_name
-          .unwrap_or(config.database.db_name),
-        app_name: config.database.app_name,
-      },
-      cli_logging: LogConfig {
-        level: env
-          .komodo_cli_logging_level
-          .unwrap_or(config.cli_logging.level),
-        stdio: env
-          .komodo_cli_logging_stdio
-          .unwrap_or(config.cli_logging.stdio),
-        pretty: env
-          .komodo_cli_logging_pretty
-          .unwrap_or(config.cli_logging.pretty),
-        location: false,
-        ansi: env
-          .komodo_cli_logging_ansi
-          .unwrap_or(config.cli_logging.ansi),
-        timestamps: env
-          .komodo_cli_logging_timestamps
-          .unwrap_or(config.cli_logging.timestamps),
-        otlp_endpoint: env
-          .komodo_cli_logging_otlp_endpoint
-          .unwrap_or(config.cli_logging.otlp_endpoint),
-        opentelemetry_service_name: env
-          .komodo_cli_logging_opentelemetry_service_name
-          .unwrap_or(config.cli_logging.opentelemetry_service_name),
-        opentelemetry_scope_name: env
-          .komodo_cli_logging_opentelemetry_scope_name
-          .unwrap_or(config.cli_logging.opentelemetry_scope_name),
-      },
-      profile: config.profile,
-    }
-  })
-}

bin/cli/src/main.rs

@@ -1,103 +0,0 @@
-#[macro_use]
-extern crate tracing;
-
-use anyhow::Context;
-use colored::Colorize;
-use komodo_client::entities::config::cli::args;
-
-use crate::config::cli_config;
-
-mod command;
-mod config;
-
-async fn app() -> anyhow::Result<()> {
-  dotenvy::dotenv().ok();
-  rustls::crypto::aws_lc_rs::default_provider()
-    .install_default()
-    .expect("Failed to install default crypto provider");
-  mogh_logger::init(&config::cli_config().cli_logging)?;
-  let args = config::cli_args();
-  let env = config::cli_env();
-  let debug_load =
-    args.debug_startup.unwrap_or(env.komodo_cli_debug_startup);
-
-  match &args.command {
-    args::Command::Config {
-      all_profiles,
-      unsanitized,
-    } => {
-      let mut config = if *unsanitized {
-        cli_config().clone()
-      } else {
-        cli_config().sanitized()
-      };
-      if !*all_profiles {
-        config.profile = Default::default();
-      }
-      if debug_load {
-        println!("\n{config:#?}");
-      } else {
-        println!(
-          "\nCLI Config {}",
-          serde_json::to_string_pretty(&config)
-            .context("Failed to serialize config for pretty print")?
-        );
-      }
-      Ok(())
-    }
-    args::Command::CoreInfo => command::core_info::handle().await,
-    args::Command::Container(container) => {
-      command::container::handle(container).await
-    }
-    args::Command::Inspect(inspect) => {
-      command::container::inspect_container(inspect).await
-    }
-    args::Command::List(list) => command::list::handle(list).await,
-    args::Command::Execute(args) => {
-      command::execute::handle(&args.execution, args.yes).await
-    }
-    args::Command::Create { command } => {
-      command::create::handle(command).await
-    }
-    args::Command::Update { command } => {
-      command::update::handle(command).await
-    }
-    args::Command::Connect(connect) => {
-      command::terminal::handle_connect(connect).await
-    }
-    args::Command::Exec(exec) => {
-      command::terminal::handle_exec(exec).await
-    }
-    args::Command::Attach(attach) => {
-      command::terminal::handle_attach(attach).await
-    }
-    args::Command::Key { command } => {
-      mogh_pki::cli::handle(command, mogh_pki::PkiKind::Mutual).await
-    }
-    args::Command::Database { command } => {
-      command::database::handle(command).await
-    }
-  }
-}
-
-#[tokio::main]
-async fn main() -> anyhow::Result<()> {
-  let mut term_signal = tokio::signal::unix::signal(
-    tokio::signal::unix::SignalKind::terminate(),
-  )?;
-  tokio::select! {
-    res = tokio::spawn(app()) => match res {
-      Ok(Err(e)) => {
-        eprintln!("{}: {e}", "ERROR".red());
-        std::process::exit(1)
-      }
-      Err(e) => {
-        eprintln!("{}: {e}", "ERROR".red());
-        std::process::exit(1)
-      },
-      Ok(_) => {}
-    },
-    _ = term_signal.recv() => {},
-  }
-  Ok(())
-}

bin/core/Cargo.toml

@@ -1,85 +0,0 @@
-[package]
-name = "komodo_core"
-version.workspace = true
-edition.workspace = true
-license.workspace = true
-homepage.workspace = true
-repository.workspace = true
-
-[[bin]]
-name = "core"
-path = "src/main.rs"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-# local
-komodo_client = { workspace = true, features = ["core"] }
-periphery_client.workspace = true
-mogh_validations.workspace = true
-interpolate.workspace = true
-mogh_secret_file.workspace = true
-formatting.workspace = true
-mogh_rate_limit.workspace = true
-transport.workspace = true
-database.workspace = true
-encoding.workspace = true
-command.workspace = true
-mogh_config.workspace = true
-mogh_logger.workspace = true
-mogh_cache.workspace = true
-mogh_pki.workspace = true
-git.workspace = true
-# mogh
-mogh_error = { workspace = true, features = ["axum"] }
-mogh_auth_client = { workspace = true, features = ["utoipa"] }
-mogh_auth_server.workspace = true
-async_timing_util.workspace = true
-partial_derive2.workspace = true
-mogh_resolver.workspace = true
-mogh_server.workspace = true
-toml_pretty.workspace = true
-slack.workspace = true
-svi.workspace = true
-# external
-aws-credential-types.workspace = true
-english-to-cron.workspace = true
-data-encoding.workspace = true
-serde_yaml_ng.workspace = true
-utoipa-scalar.workspace = true
-futures-util.workspace = true
-aws-sdk-ec2.workspace = true
-urlencoding.workspace = true
-aws-config.workspace = true
-tokio-util.workspace = true
-axum-extra.workspace = true
-serde_json.workspace = true
-typeshare.workspace = true
-chrono-tz.workspace = true
-indexmap.workspace = true
-wildcard.workspace = true
-arc-swap.workspace = true
-serde_qs.workspace = true
-colored.workspace = true
-tracing.workspace = true
-reqwest.workspace = true
-dotenvy.workspace = true
-anyhow.workspace = true
-bcrypt.workspace = true
-croner.workspace = true
-chrono.workspace = true
-rustls.workspace = true
-utoipa.workspace = true
-bytes.workspace = true
-tokio.workspace = true
-serde.workspace = true
-strum.workspace = true
-regex.workspace = true
-axum.workspace = true
-toml.workspace = true
-uuid.workspace = true
-envy.workspace = true
-hmac.workspace = true
-sha2.workspace = true
-hex.workspace = true
-url.workspace = true

bin/core/aio.Dockerfile

@@ -1,70 +0,0 @@
-## All in one, multi stage compile + runtime Docker build for your architecture.
-
-# Build Core
-FROM rust:1.97.1-trixie AS core-builder
-RUN cargo install cargo-strip
-
-WORKDIR /builder
-COPY Cargo.toml Cargo.lock ./
-COPY ./lib ./lib
-COPY ./client/core/rs ./client/core/rs
-COPY ./client/periphery ./client/periphery
-COPY ./bin/core ./bin/core
-COPY ./bin/cli ./bin/cli
-COPY ./xtask ./xtask
-
-# Compile app
-RUN cargo build -p komodo_core --release && \
-  cargo build -p komodo_cli --release && \
-  cargo strip
-
-# Build UI
-FROM node:22.12-alpine AS ui-builder
-WORKDIR /builder
-COPY ./ui ./ui
-COPY ./client/core/ts ./client
-RUN cd client && yarn && yarn build && yarn link
-RUN cd ui && yarn link komodo_client && yarn && yarn build
-
-# Final Image
-FROM debian:trixie-slim
-
-COPY ./bin/core/starship.toml /starship.toml
-COPY ./bin/core/debian-deps.sh .
-RUN sh ./debian-deps.sh && rm ./debian-deps.sh
-
-# Setup an application directory
-WORKDIR /app
-
-# Copy
-COPY ./config/core.config.toml /config/.default.config.toml
-COPY --from=ui-builder /builder/ui/dist /app/ui
-COPY --from=core-builder /builder/target/release/core /usr/local/bin/core
-COPY --from=core-builder /builder/target/release/km /usr/local/bin/km
-COPY --from=denoland/deno:bin /deno /usr/local/bin/deno
-
-# Set $DENO_DIR and preload external Deno deps
-ENV DENO_DIR=/action-cache/deno
-RUN mkdir /action-cache && \
-  cd /action-cache && \
-  deno install jsr:@std/yaml jsr:@std/toml
-
-COPY ./bin/entrypoint.sh /usr/local/bin/entrypoint.sh
-RUN chmod +x /usr/local/bin/entrypoint.sh
-
-# Hint at the port
-EXPOSE 9120
-
-ENV KOMODO_CLI_CONFIG_PATHS="/config"
-# This ensures any `komodo.cli.*` takes precedence over the Core `/config/*config.*`
-ENV KOMODO_CLI_CONFIG_KEYWORDS="*config.*,*komodo.cli*.*"
-
-ENTRYPOINT [ "entrypoint.sh" ]
-CMD [ "core" ]
-
-# Label to prevent Komodo from stopping with StopAllContainers
-LABEL komodo.skip="true"
-# Label for Ghcr
-LABEL org.opencontainers.image.source="https://github.com/moghtech/komodo"
-LABEL org.opencontainers.image.description="Komodo Core"
-LABEL org.opencontainers.image.licenses="GPL-3.0"

bin/core/debian-deps.sh

@@ -1,14 +0,0 @@
-#!/bin/bash
-
-## Core deps installer
-
-apt-get update
-apt-get install -y git curl ca-certificates iproute2
-
-rm -rf /var/lib/apt/lists/*
-
-# Starship prompt
-curl -sS https://starship.rs/install.sh | sh -s -- --yes --bin-dir /usr/local/bin
-echo 'export STARSHIP_CONFIG=/starship.toml' >> /root/.bashrc
-echo 'eval "$(starship init bash)"' >> /root/.bashrc
-