fujin-cli 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

fujin/commands/app.py

@@ -5,6 +5,7 @@ from typing import Annotated
 import cappa
 
 from fujin.commands import BaseCommand
+from fujin.config import InstallationMode
 
 
 @cappa.command(help="Run application-related tasks")
@@ -25,11 +26,12 @@ class App(BaseCommand):
                 "app_bin": self.config.app_bin,
                 "local_version": self.config.version,
                 "remote_version": remote_version,
-                "python_version": self.config.python_version,
                 "rollback_targets": ", ".join(rollback_targets.split("\n"))
                 if rollback_targets
                 else "N/A",
             }
+            if self.config.installation_mode == InstallationMode.PY_PACKAGE:
+                infos["python_version"] = self.config.python_version
             pm = self.create_process_manager(conn)
             services: dict[str, bool] = pm.is_active()
 

fujin/commands/config.py

@@ -16,13 +16,14 @@ class ConfigCMD(BaseCommand):
             "app": self.config.app_name,
             "app_bin": self.config.app_bin,
             "version": self.config.version,
-            "python_version": self.config.python_version,
             "build_command": self.config.build_command,
             "release_command": self.config.release_command,
+            "installation_mode": self.config.installation_mode,
             "distfile": self.config.distfile,
-            "requirements": self.config.requirements,
             "webserver": f"{{ upstream = '{self.config.webserver.upstream}', type = '{self.config.webserver.type}' }}",
         }
+        if self.config.python_version:
+            general_config["python_version"] = self.config.python_version
         general_config_text = "\n".join(
             f"[bold green]{key}:[/bold green] {value}"
             for key, value in general_config.items()

fujin/commands/deploy.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
 import subprocess
+from pathlib import Path
 
 import cappa
 
 from fujin.commands import BaseCommand
+from fujin.config import InstallationMode
 from fujin.connection import Connection
 
 
@@ -16,21 +18,20 @@ class Deploy(BaseCommand):
         self.build_app()
 
         with self.connection() as conn:
+            process_manager = self.create_process_manager(conn)
             conn.run(f"mkdir -p {self.app_dir}")
             with conn.cd(self.app_dir):
                 self.create_hook_manager(conn).pre_deploy()
                 self.transfer_files(conn)
-
-        with self.app_environment() as conn:
-            process_manager = self.create_process_manager(conn)
-            self.install_project(conn)
-            self.release(conn)
-            process_manager.install_services()
-            process_manager.reload_configuration()
-            process_manager.restart_services()
-            self.create_web_proxy(conn).setup()
-            self.update_version_history(conn)
-            self.prune_assets(conn)
+                self.install_project(conn)
+            with self.app_environment() as app_conn:
+                self.release(app_conn)
+                process_manager.install_services()
+                process_manager.reload_configuration()
+                process_manager.restart_services()
+                self.create_web_proxy(app_conn).setup()
+                self.update_version_history(app_conn)
+                self.prune_assets(app_conn)
             self.create_hook_manager(conn).post_deploy()
         self.stdout.output("[green]Project deployment completed successfully![/green]")
         self.stdout.output(
@@ -47,24 +48,37 @@ class Deploy(BaseCommand):
     def versioned_assets_dir(self) -> str:
         return f"{self.app_dir}/v{self.config.version}"
 
-    def transfer_files(self, conn: Connection, skip_requirements: bool = False):
+    def transfer_files(self, conn: Connection):
         if not self.config.host.envfile.exists():
             raise cappa.Exit(f"{self.config.host.envfile} not found", code=1)
-
-        if not self.config.requirements.exists():
-            raise cappa.Exit(f"{self.config.requirements} not found", code=1)
         conn.put(str(self.config.host.envfile), f"{self.app_dir}/.env")
         conn.run(f"mkdir -p {self.versioned_assets_dir}")
-        if not skip_requirements:
-            conn.put(
-                str(self.config.requirements),
-                f"{self.versioned_assets_dir}/requirements.txt",
-            )
         distfile_path = self.config.get_distfile_path()
         conn.put(
             str(distfile_path),
             f"{self.versioned_assets_dir}/{distfile_path.name}",
         )
+
+    def install_project(
+        self, conn: Connection, version: str | None = None, *, skip_setup: bool = False
+    ):
+        version = version or self.config.version
+        if self.config.installation_mode == InstallationMode.PY_PACKAGE:
+            self._install_python_package(conn, version, skip_setup)
+        else:
+            self._install_binary(conn, version)
+
+    def _install_python_package(
+        self, conn: Connection, version: str, skip_setup: bool = False
+    ):
+        if not skip_setup and self.config.requirements:
+            requirements = Path(self.config.requirements)
+            if not requirements.exists():
+                raise cappa.Exit(f"{self.config.requirements} not found", code=1)
+            conn.put(
+                Path(self.config.requirements).resolve(),
+                f"{self.versioned_assets_dir}/requirements.txt",
+            )
         appenv = f"""
 set -a  # Automatically export all variables
 source .env
@@ -73,22 +87,30 @@ export UV_COMPILE_BYTECODE=1
 export UV_PYTHON=python{self.config.python_version}
 export PATH=".venv/bin:$PATH"
 """
-        conn.run(f"echo '{appenv.strip()}' > .appenv")
-
-    def install_project(
-        self, conn: Connection, version: str | None = None, *, skip_setup: bool = False
-    ):
-        if self.config.skip_project_install:
-            return
-        version = version or self.config.version
+        conn.run(f"echo '{appenv.strip()}' > {self.app_dir}/.appenv")
         versioned_assets_dir = f"{self.app_dir}/v{version}"
         if not skip_setup:
             conn.run("uv venv")
-            conn.run(f"uv pip install -r {versioned_assets_dir}/requirements.txt")
+            if self.config.requirements:
+                conn.run(f"uv pip install -r {versioned_assets_dir}/requirements.txt")
         conn.run(
             f"uv pip install {versioned_assets_dir}/{self.config.get_distfile_path(version).name}"
         )
 
+    def _install_binary(self, conn: Connection, version: str):
+        appenv = f"""
+set -a  # Automatically export all variables
+source .env
+set +a  # Stop automatic export
+export PATH="{self.app_dir}:$PATH"
+"""
+        conn.run(f"echo '{appenv.strip()}' > {self.app_dir}/.appenv")
+        full_path_app_bin = f"{self.app_dir}/{self.config.app_bin}"
+        conn.run(f"rm {full_path_app_bin}", warn=True)
+        conn.run(
+            f"ln -s {self.versioned_assets_dir}/{self.config.get_distfile_path(version).name} {full_path_app_bin}"
+        )
+
     def release(self, conn: Connection):
         if self.config.release_command:
             conn.run(f"source .env && {self.config.release_command}")

fujin/commands/down.py

@@ -28,7 +28,7 @@ class Down(BaseCommand):
             confirm = Confirm.ask(
                 f"""[red]You are about to delete all project files, stop all services, and remove all configurations on the host {self.config.host.ip} for the project {self.config.app_name}. Any assets in your project folder will be lost (sqlite not in there ?). Are you sure you want to proceed? This action is irreversible.[/red]""",
             )
-        except KeyboardInterrupt as e:
+        except KeyboardInterrupt:
             raise cappa.Exit("Teardown aborted", code=0)
         if not confirm:
             return

fujin/commands/init.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Annotated
 
@@ -7,31 +8,28 @@ import cappa
 import tomli_w
 
 from fujin.commands import BaseCommand
-from fujin.config import tomllib
+from fujin.config import tomllib, InstallationMode
 
 
 @cappa.command(help="Generate a sample configuration file")
+@dataclass
 class Init(BaseCommand):
     profile: Annotated[
-        str, cappa.Arg(choices=["simple", "falco"], short="-p", long="--profile")
+        str,
+        cappa.Arg(choices=["simple", "falco", "binary"], short="-p", long="--profile"),
     ] = "simple"
 
     def __call__(self):
         fujin_toml = Path("fujin.toml")
         if fujin_toml.exists():
             raise cappa.Exit("fujin.toml file already exists", code=1)
-        profile_to_func = {"simple": simple_config, "falco": falco_config}
+        profile_to_func = {
+            "simple": simple_config,
+            "falco": falco_config,
+            "binary": binary_config,
+        }
         app_name = Path().resolve().stem.replace("-", "_").replace(" ", "_").lower()
         config = profile_to_func[self.profile](app_name)
-        if not Path(".python-version").exists():
-            config["python_version"] = "3.12"
-        pyproject_toml = Path("pyproject.toml")
-        if pyproject_toml.exists():
-            pyproject = tomllib.loads(pyproject_toml.read_text())
-            config["app"] = pyproject.get("project", {}).get("name", app_name)
-            if pyproject.get("project", {}).get("version"):
-                # fujin will read the version itself from the pyproject
-                config.pop("version")
         fujin_toml.write_text(tomli_w.dumps(config))
         self.stdout.output(
             "[green]Sample configuration file generated successfully![/green]"
@@ -39,18 +37,20 @@ class Init(BaseCommand):
 
 
 def simple_config(app_name) -> dict:
-    return {
+    config = {
         "app": app_name,
-        "version": "0.1.0",
+        "version": "0.0.1",
         "build_command": "uv build && uv pip compile pyproject.toml -o requirements.txt",
         "distfile": f"dist/{app_name}-{{version}}-py3-none-any.whl",
+        "requirements": "requirements.txt",
         "webserver": {
-            "upstream": "localhost:8000",
+            "upstream": f"unix//run/{app_name}.sock",
             "type": "fujin.proxies.caddy",
         },
         "release_command": f"{app_name} migrate",
+        "installation_mode": InstallationMode.PY_PACKAGE,
         "processes": {
-            "web": f".venv/bin/gunicorn {app_name}.wsgi:application --bind 0.0.0.0:8000"
+            "web": f".venv/bin/gunicorn {app_name}.wsgi:application --bind unix//run/{app_name}.sock"
         },
         "aliases": {"shell": "server exec --appenv -i bash"},
         "host": {
@@ -60,6 +60,16 @@ def simple_config(app_name) -> dict:
             "envfile": ".env.prod",
         },
     }
+    if not Path(".python-version").exists():
+        config["python_version"] = "3.12"
+    pyproject_toml = Path("pyproject.toml")
+    if pyproject_toml.exists():
+        pyproject = tomllib.loads(pyproject_toml.read_text())
+        config["app"] = pyproject.get("project", {}).get("name", app_name)
+        if pyproject.get("project", {}).get("version"):
+            # fujin will read the version itself from the pyproject
+            config.pop("version")
+    return config
 
 
 def falco_config(app_name: str) -> dict:
@@ -71,6 +81,10 @@ def falco_config(app_name: str) -> dict:
                 "web": f".venv/bin/{config['app']} prodserver",
                 "worker": f".venv/bin/{config['app']} qcluster",
             },
+            "webserver": {
+                "upstream": "localhost:8000",
+                "type": "fujin.proxies.caddy",
+            },
             "aliases": {
                 "console": "app exec -i shell_plus",
                 "dbconsole": "app exec -i dbshell",
@@ -80,3 +94,26 @@ def falco_config(app_name: str) -> dict:
         }
     )
     return config
+
+
+def binary_config(app_name: str) -> dict:
+    return {
+        "app": app_name,
+        "version": "0.0.1",
+        "build_command": "just build-bin",
+        "distfile": f"dist/bin/{app_name}-{{version}}",
+        "webserver": {
+            "upstream": "localhost:8000",
+            "type": "fujin.proxies.caddy",
+        },
+        "release_command": f"{app_name} migrate",
+        "installation_mode": InstallationMode.BINARY,
+        "processes": {"web": f"{app_name} prodserver"},
+        "aliases": {"shell": "server exec --appenv -i bash"},
+        "host": {
+            "ip": "127.0.0.1",
+            "user": "root",
+            "domain_name": f"{app_name}.com",
+            "envfile": ".env.prod",
+        },
+    }

fujin/commands/proxy.py

@@ -2,6 +2,7 @@ from dataclasses import dataclass
 from typing import Annotated
 
 import cappa
+from rich.prompt import Confirm
 
 from fujin.commands import BaseCommand
 
@@ -13,11 +14,21 @@ class Proxy(BaseCommand):
     def install(self):
         with self.connection() as conn:
             self.create_web_proxy(conn).install()
+        self.stdout.output("[green]Proxy installed successfully![/green]")
 
     @cappa.command(help="Uninstall the proxy from the remote host")
     def uninstall(self):
+        try:
+            confirm = Confirm.ask(
+                f"[red]Uninstalling the proxy will remove all current configurations. Are you sure you want to proceed?"
+            )
+        except KeyboardInterrupt:
+            raise cappa.Exit("Teardown aborted", code=0)
+        if not confirm:
+            return
         with self.connection() as conn:
             self.create_web_proxy(conn).uninstall()
+        self.stdout.output("[green]Proxy uninstalled successfully![/green]")
 
     @cappa.command(help="Start the proxy on the remote host")
     def start(self):

fujin/commands/redeploy.py

@@ -1,11 +1,14 @@
 from __future__ import annotations
 
 import hashlib
+from pathlib import Path
 
 import cappa
 
 from fujin.commands import BaseCommand
 from .deploy import Deploy
+from fujin.config import InstallationMode
+from fujin.connection import Connection
 
 
 @cappa.command(help="Redeploy the application to apply code and environment changes")
@@ -13,36 +16,46 @@ class Redeploy(BaseCommand):
     def __call__(self):
         deploy = Deploy()
         deploy.build_app()
-        local_requirements = hashlib.md5(
-            self.config.requirements.read_bytes()
-        ).hexdigest()
+
         with self.app_environment() as conn:
             hook_manager = self.create_hook_manager(conn)
             hook_manager.pre_deploy()
-            current_host_version = conn.run(
-                "head -n 1 .versions", warn=True, hide=True
-            ).stdout.strip()
-            try:
-                host_requirements = (
-                    conn.run(
-                        f"md5sum v{current_host_version}/requirements.txt",
-                        warn=True,
-                        hide=True,
-                    )
-                    .stdout.strip()
-                    .split()[0]
-                )
-                skip_requirements = host_requirements == local_requirements
-            except IndexError:
-                skip_requirements = False
-            deploy.transfer_files(conn, skip_requirements=skip_requirements)
-            if skip_requirements and current_host_version != self.config.version:
-                conn.run(
-                    f"cp v{current_host_version}/requirements.txt  {deploy.versioned_assets_dir}/requirements.txt "
-                )
-            deploy.install_project(conn, skip_setup=skip_requirements)
+            deploy.transfer_files(conn)
+            requirements_copied = self._copy_requirements_if_needed(conn)
+            deploy.install_project(conn, skip_setup=requirements_copied)
             deploy.release(conn)
             self.create_process_manager(conn).restart_services()
             deploy.update_version_history(conn)
             hook_manager.post_deploy()
             self.stdout.output("[green]Redeployment completed successfully![/green]")
+
+    def _copy_requirements_if_needed(self, conn: Connection) -> bool:
+        if (
+            not self.config.requirements
+            or self.config.installation_mode == InstallationMode.BINARY
+        ):
+            return False
+        local_requirements = hashlib.md5(
+            Path(self.config.requirements).read_bytes()
+        ).hexdigest()
+        current_host_version = conn.run(
+            "head -n 1 .versions", warn=True, hide=True
+        ).stdout.strip()
+        try:
+            host_requirements = (
+                conn.run(
+                    f"md5sum v{current_host_version}/requirements.txt",
+                    warn=True,
+                    hide=True,
+                )
+                .stdout.strip()
+                .split()[0]
+            )
+            skip_requirements = host_requirements == local_requirements
+        except IndexError:
+            return False
+        if skip_requirements and current_host_version != self.config.version:
+            conn.run(
+                f"cp v{current_host_version}/requirements.txt  {self.app_dir}/v{self.config.version}/requirements.txt "
+            )
+        return True

fujin/commands/server.py

@@ -38,11 +38,6 @@ class Server(BaseCommand):
                 "[green]Server bootstrap completed successfully![/green]"
             )
 
-    @cappa.command(help="Stop and uninstall the web proxy")
-    def uninstall_proxy(self):
-        with self.connection() as conn:
-            self.create_web_proxy(conn).uninstall()
-
     @cappa.command(
         help="Execute an arbitrary command on the server, optionally in interactive mode"
     )

fujin/config.py

@@ -5,18 +5,14 @@ app
 ---
 The name of your project or application. Must be a valid Python package name.
 
-app_bin
--------
-Path to your application's executable. Used by the **app** subcommand for remote execution.
-Default: ``.venv/bin/{app}``
-
 version
 --------
 The version of your project to build and deploy. If not specified, automatically parsed from ``pyproject.toml`` under ``project.version``.
 
 python_version
 --------------
-The Python version for your virtualenv. If not specified, automatically parsed from ``.python-version`` file.
+The Python version for your virtualenv. If not specified, automatically parsed from ``.python-version`` file. This is only
+required if the installation mode is set to ``python-package``
 
 versions_to_keep
 ----------------
@@ -32,14 +28,20 @@ distfile
 Path to your project's distribution file. This should be the main artifact containing everything needed to run your project on the server.
 Supports version placeholder, e.g., ``dist/app_name-{version}-py3-none-any.whl``
 
+installation_mode
+-----------------
+
+Indicates whether the ``distfile`` is a Python package or a self-contained executable. The possible values are ``python-package`` and ``binary``.
+The ``binary`` option disables specific Python-related features, such as virtual environment creation and requirements installation. ``fujin`` will assume the provided
+``distfile`` already contains all the necessary dependencies to run your program.
+
 release_command
 ---------------
 Optional command to run at the end of deployment (e.g., database migrations).
 
 requirements
 ------------
-Path to your requirements file.
-Default: ``requirements.txt``
+Optional path to your requirements file. This will only be used when the installation mode is set to ``python-package``
 
 Webserver
 ---------
@@ -63,7 +65,8 @@ statics
 ~~~~~~~
 
 Defines the mapping of URL paths to local directories for serving static files. The syntax and support for static
-file serving depend on the selected reverse proxy.
+file serving depend on the selected reverse proxy. The directories you map should be accessible by the web server, meaning
+with read permissions for the ``www-data`` group; a reliable choice is ``/var/www``.
 
 Example:
 
@@ -72,7 +75,7 @@ Example:
     [webserver]
     upstream = "unix//run/project.sock"
     type = "fujin.proxies.caddy"
-    statics = { "/static/*" = "/var/www/example.com/static/" }
+    statics = { "/static/*" = "/var/www/myproject/static/" }
 
 processes
 ---------
@@ -159,6 +162,7 @@ from __future__ import annotations
 
 import os
 import sys
+from functools import cached_property
 from pathlib import Path
 
 import msgspec
@@ -170,31 +174,36 @@ if sys.version_info >= (3, 11):
 else:
     import tomli as tomllib
 
-from .hooks import HooksDict
+from .hooks import HooksDict, StrEnum
+
+
+class InstallationMode(StrEnum):
+    PY_PACKAGE = "python-package"
+    BINARY = "binary"
 
 
 class Config(msgspec.Struct, kw_only=True):
     app_name: str = msgspec.field(name="app")
-    app_bin: str = ".venv/bin/{app}"
     version: str = msgspec.field(default_factory=lambda: read_version_from_pyproject())
     versions_to_keep: int | None = 5
-    python_version: str = msgspec.field(default_factory=lambda: find_python_version())
+    python_version: str | None = None
     build_command: str
     release_command: str | None = None
-    skip_project_install: bool = False
+    installation_mode: InstallationMode
     distfile: str
     aliases: dict[str, str] = msgspec.field(default_factory=dict)
     host: HostConfig
     processes: dict[str, str] = msgspec.field(default_factory=dict)
     process_manager: str = "fujin.process_managers.systemd"
     webserver: Webserver
-    _requirements: str = msgspec.field(name="requirements", default="requirements.txt")
+    requirements: str | None = None
     hooks: HooksDict = msgspec.field(default_factory=dict)
     local_config_dir: Path = Path(".fujin")
 
     def __post_init__(self):
-        self.app_bin = self.app_bin.format(app=self.app_name)
-        # self._distfile = self._distfile.format(version=self.version)
+        if self.installation_mode == InstallationMode.PY_PACKAGE:
+            if not self.python_version:
+                self.python_version = find_python_version()
 
         if "web" not in self.processes and self.webserver.type != "fujin.proxies.dummy":
             raise ValueError(
@@ -202,8 +211,10 @@ class Config(msgspec.Struct, kw_only=True):
             )
 
     @property
-    def requirements(self) -> Path:
-        return Path(self._requirements)
+    def app_bin(self) -> str:
+        if self.installation_mode == InstallationMode.PY_PACKAGE:
+            return f".venv/bin/{self.app_name}"
+        return self.app_name
 
     def get_distfile_path(self, version: str | None = None) -> Path:
         version = version or self.version

fujin/proxies/caddy.py

@@ -49,6 +49,9 @@ class WebProxy(msgspec.Struct):
         return self.conn.run(*args, **kwargs, pty=True)
 
     def install(self):
+        result = self.conn.run(f"command -v caddy", warn=True, hide=True)
+        if result.ok:
+            return
         version = get_latest_gh_tag()
         download_url = GH_DOWNL0AD_URL.format(version=version)
         filename = GH_TAR_FILENAME.format(version=version)
@@ -71,9 +74,9 @@ class WebProxy(msgspec.Struct):
         )
         self.run_pty("sudo systemctl daemon-reload")
         self.run_pty("sudo systemctl enable --now caddy-api")
-        # to initialize the caddy config, when running setup on a fresh caddy setup it fails because the key config/apps was not previously defined
-        # TODO this will reset the config of any existing server, should probably do I check before running this
-        self.conn.run("""curl --silent http://localhost:2019/config/ -d '{"apps":{"http": {"servers": {}}}}' -H 'Content-Type: application/json'""")
+        self.conn.run(
+            """curl --silent http://localhost:2019/config/ -d '{"apps":{"http": {"servers": {"srv0":{"listen":[":443"]}}}}}' -H 'Content-Type: application/json'"""
+        )
 
     def uninstall(self):
         self.stop()
@@ -83,51 +86,31 @@ class WebProxy(msgspec.Struct):
         self.run_pty("sudo userdel caddy")
 
     def setup(self):
-        config = (
+        current_config = json.loads(
+            self.conn.run(
+                "curl http://localhost:2019/config/apps/http/servers/srv0", hide=True
+            ).stdout.strip()
+        )
+        existing_routes: list[dict] = current_config.get("routes", [])
+        new_routes = [r for r in existing_routes if r.get("group") != self.app_name]
+        routes = (
             json.loads(self.config_file.read_text())
             if self.config_file.exists()
-            else self._get_config()
+            else self._get_routes()
         )
-        self.conn.run(f"echo '{json.dumps(config)}' > caddy.json")
-        self.conn.run(
-            f"curl localhost:2019/config/apps/http/servers/{self.app_name} -H 'Content-Type: application/json' -d @caddy.json"
-        )
-        # TODO: stop when received an {"error":"loading config: loading new config: http app module: start: listening on :443: listen tcp :443: bind: permission denied"}, not a 200 ok
-
-    def teardown(self):
-        self.conn.run(f"echo '{json.dumps({})}' > caddy.json")
+        new_routes.append(routes)
+        current_config["routes"] = new_routes
         self.conn.run(
-            f"curl localhost:2019/config/apps/http/servers/{self.app_name} -H 'Content-Type: application/json' -d @caddy.json"
+            f"curl localhost:2019/config/apps/http/servers/srv0 -H 'Content-Type: application/json' -d '{json.dumps(current_config)}'"
         )
 
-    def start(self) -> None:
-        self.run_pty("sudo systemctl start caddy-api")
-
-    def stop(self) -> None:
-        self.run_pty("sudo systemctl stop caddy-api")
-
-    def status(self) -> None:
-        self.run_pty("sudo systemctl status caddy-api", warn=True)
-
-    def restart(self) -> None:
-        self.run_pty("sudo systemctl restart caddy-api")
-
-    def logs(self) -> None:
-        self.run_pty(f"sudo journalctl -u caddy-api -f", warn=True)
-
-    def export_config(self) -> None:
-        self.config_file.write_text(json.dumps(self._get_config()))
-
-    def _get_config(self) -> dict:
+    def _get_routes(self) -> dict:
         handle = []
-        config = {
-            "listen": [":443"],
-            "routes": [
-                {
-                    "match": [{"host": [self.domain_name]}],
-                    "handle": handle,
-                }
-            ],
+        routes = {
+            "group": self.app_name,
+            "match": [{"host": [self.domain_name]}],
+            "terminal": True,
+            "handle": handle,
         }
         reverse_proxy = {
             "handler": "reverse_proxy",
@@ -135,14 +118,14 @@ class WebProxy(msgspec.Struct):
         }
         if not self.statics:
             handle.append(reverse_proxy)
-            return config
-        routes = []
-        handle.append({"handler": "subroute", "routes": routes})
+            return routes
+        sub_routes = []
+        handle.append({"handler": "subroute", "routes": sub_routes})
         for path, directory in self.statics.items():
             strip_path_prefix = path.replace("/*", "")
             if strip_path_prefix.endswith("/"):
                 strip_path_prefix = strip_path_prefix[:-1]
-            routes.append(
+            sub_routes.append(
                 {
                     "handle": [
                         {
@@ -170,8 +153,39 @@ class WebProxy(msgspec.Struct):
                     "match": [{"path": [path]}],
                 }
             )
-        routes.append({"handle": [reverse_proxy]})
-        return config
+        sub_routes.append({"handle": [reverse_proxy]})
+        return routes
+
+    def teardown(self):
+        current_config = json.loads(
+            self.conn.run(
+                "curl http://localhost:2019/config/apps/http/servers/srv0"
+            ).stdout.strip()
+        )
+        existing_routes: list[dict] = current_config.get("routes", [])
+        new_routes = [r for r in existing_routes if r.get("group") != self.app_name]
+        current_config["routes"] = new_routes
+        self.conn.run(
+            f"curl localhost:2019/config/apps/http/servers/srv0 -H 'Content-Type: application/json' -d '{json.dumps(current_config)}'"
+        )
+
+    def start(self) -> None:
+        self.run_pty("sudo systemctl start caddy-api")
+
+    def stop(self) -> None:
+        self.run_pty("sudo systemctl stop caddy-api")
+
+    def status(self) -> None:
+        self.run_pty("sudo systemctl status caddy-api", warn=True)
+
+    def restart(self) -> None:
+        self.run_pty("sudo systemctl restart caddy-api")
+
+    def logs(self) -> None:
+        self.run_pty(f"sudo journalctl -u caddy-api -f", warn=True)
+
+    def export_config(self) -> None:
+        self.config_file.write_text(json.dumps(self._get_routes()))
 
 
 def get_latest_gh_tag() -> str:

{fujin_cli-0.4.0.dist-info → fujin_cli-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: fujin-cli
-Version: 0.4.0
+Version: 0.5.0
 Summary: Add your description here
 Project-URL: Documentation, https://github.com/falcopackages/fujin#readme
 Project-URL: Issues, https://github.com/falcopackages/fujin/issues

{fujin_cli-0.4.0.dist-info → fujin_cli-0.5.0.dist-info}/RECORD

@@ -1,35 +1,35 @@
 fujin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fujin/__main__.py,sha256=St0VnEWhRRw_ukAddAwDGFliLqQT3xlone-9JIONlDI,1702
-fujin/config.py,sha256=OYcQPhYYcLJ2ImVP-BNodWvaJ6Y5mRIeB9R3cohbV94,8678
+fujin/config.py,sha256=r2Rdd7ErGGTQPLMJlqZbPEQXd6fSSQB7PNbyaurEQsQ,9394
 fujin/connection.py,sha256=ZkYaNykRFj9Yr-K-vOrZtVVGUDurDm6W7OQrgct71CA,2428
 fujin/errors.py,sha256=74Rh-Sgql1YspPdR_akQ2G3xZ48zecyafYCptpaFo1A,73
 fujin/hooks.py,sha256=QHIqxLxujG2U70UkN1BpUplE6tTqn7pFJP5oHde1tUQ,1350
 fujin/commands/__init__.py,sha256=uIGGXt8YofL5RZn8KIy153ioWGoCl32ffHtqOhB-6ZM,78
 fujin/commands/_base.py,sha256=o3R4-c3XeFWTIW3stiUdrcCPwdjzfjUVIpZy2L1-gZ4,2525
-fujin/commands/app.py,sha256=LUC4mmvkp1F4a96UP9hgd5y_R9HA8Xc_TtNAsYtXvvs,5153
-fujin/commands/config.py,sha256=HAiea_ebhvBzUG7vddMH3ldjZKRHU1KFaZlDZI1XmMg,2322
-fujin/commands/deploy.py,sha256=mUvlDF6yv05wnQqhsFC-LCPVvaJVfnQnK97CFB_ttVY,4427
+fujin/commands/app.py,sha256=mazb4dCTdR5juh79bL3a9b68Nd6O8u_nR9IgYqQlqWE,5279
+fujin/commands/config.py,sha256=xdfd1OZLxw2YZldiAbW5rq5EBXEaXbUC-I7FKLRfzIQ,2387
+fujin/commands/deploy.py,sha256=oAOLUrtHjHkmIA3D0AiaJRWEsfVk51_I29kRC_FhjYo,5463
 fujin/commands/docs.py,sha256=b5FZ8AgoAfn4q4BueEQvM2w5HCuh8-rwBqv_CRFVU8E,349
-fujin/commands/down.py,sha256=JrwDZjcqyx5Mx7IzcAkzq1zAPBD5MQMIS4gzBEUz3JM,1721
-fujin/commands/init.py,sha256=MqZeEH7OL4knOuR8D84MxmeurDMXSr8XEXqcGxf6Xoo,2895
-fujin/commands/proxy.py,sha256=w8XOhirD5lLnmW3SC27bahoIt2XtgydQ-8LxOP-DpYM,2552
+fujin/commands/down.py,sha256=v1lAq70ApktjeHRB_1sCzjmKH8t6EXqyL4RTt7OE-f0,1716
+fujin/commands/init.py,sha256=IguExzQEPJ5CbWzG-mI6hIXUw2fd2rAEA04FK6-5l18,4021
+fujin/commands/proxy.py,sha256=ajXwboS0gDDiMWW7b9rtWU6WPF1h7JYYeycDyU-hQfg,3053
 fujin/commands/prune.py,sha256=C2aAN6AUS84jgRg1eiCroyiuZyaZDmf5yvGAQY9xkcg,1517
-fujin/commands/redeploy.py,sha256=suSr6S54oLsnKGjJgq3uHxCRFcrCX5C-5BkmH5MzQks,1864
+fujin/commands/redeploy.py,sha256=JvCJBZBcCKkUw1efZwRPJMLUAV8oqBAZeSbUBLHyn3k,2185
 fujin/commands/rollback.py,sha256=BN9vOTEBcSSpFIfck9nzWvMVO7asVC20lQbcNrxRchg,2009
 fujin/commands/secrets.py,sha256=1xZQVkvbopsAcWUocLstxPKxsvmGoE2jWip5hdTrP50,162
-fujin/commands/server.py,sha256=n0FZbNI4IO5AOMJTIVfJqgb32-QSrWEu0IVwfREsRbY,3637
+fujin/commands/server.py,sha256=0N_P_Luj31t56riZ8GfgRqW3vRHiw0cDrlp3PFoyWn8,3453
 fujin/commands/up.py,sha256=DgDN-1mc_mMHJRCIvcB947Cd5a7phunu9NpXloGK0UU,419
 fujin/process_managers/__init__.py,sha256=MhhfTBhm64zWRAKgjvsZRIToOUJus60vGScbAjqpQ6Y,994
 fujin/process_managers/systemd.py,sha256=qG_4Ew8SEWtaTFOAW_XZXsMO2WjFWZ4dp5nBwAPBObk,5603
 fujin/proxies/__init__.py,sha256=UuWYU175tkdaz1WWRCDDpQgGfFVYYNR9PBxA3lTCNr0,695
-fujin/proxies/caddy.py,sha256=OkQkQXlVVw3KYkVNV8tAfpHnqZEImo5bStr8dbkM2F0,7540
+fujin/proxies/caddy.py,sha256=dzLD8s664_kIK-1hCE3y50JIwBd8kK9yS1LynUDRVSE,7908
 fujin/proxies/dummy.py,sha256=qBKSn8XNEA9SVwB7GzRNX2l9Iw6tUjo2CFqZjWi0FjY,465
 fujin/proxies/nginx.py,sha256=8AkbJAjj6B0fxgv671mGDbx3LY_dY5wxFov80XmSfUY,4139
 fujin/templates/simple.service,sha256=-lyKjmSyfHGucP4O_vRQE1NNaHq0Qjsc0twdwoRLgI0,321
 fujin/templates/web.service,sha256=NZ7ZeaFvV_MZTBn8QqRQeu8PIrWHf3aWYWNzjOQeqCw,685
 fujin/templates/web.socket,sha256=2lJsiOHlMJL0YlN7YBLLnr5zqsytPEt81yP34nk0dmc,173
-fujin_cli-0.4.0.dist-info/METADATA,sha256=Vf2x0v7d1QVV9xE9UQn2LNtDyVCFmASfDcwTcpgpAgU,4396
-fujin_cli-0.4.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-fujin_cli-0.4.0.dist-info/entry_points.txt,sha256=Y_TBtKt3j11qhwquMexZR5yqnDEqOBDACtresqQFE-s,46
-fujin_cli-0.4.0.dist-info/licenses/LICENSE.txt,sha256=0QF8XfuH0zkIHhSet6teXfiCze6JSdr8inRkmLLTDyo,1099
-fujin_cli-0.4.0.dist-info/RECORD,,
+fujin_cli-0.5.0.dist-info/METADATA,sha256=_-oV3GG6q1UZHhoXF5oOVTL8t1qOk_mRhmrUNz9CB-E,4396
+fujin_cli-0.5.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+fujin_cli-0.5.0.dist-info/entry_points.txt,sha256=Y_TBtKt3j11qhwquMexZR5yqnDEqOBDACtresqQFE-s,46
+fujin_cli-0.5.0.dist-info/licenses/LICENSE.txt,sha256=0QF8XfuH0zkIHhSet6teXfiCze6JSdr8inRkmLLTDyo,1099
+fujin_cli-0.5.0.dist-info/RECORD,,