fujin-cli 0.4.0__py3-none-any.whl → 0.6.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,27 +37,38 @@ 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": {
-            "ip": "127.0.0.1",
             "user": "root",
             "domain_name": f"{app_name}.com",
             "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 +80,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 +93,25 @@ 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": {
+            "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,18 @@ 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``
+
+requirements
+------------
+Optional path to your requirements file. This will only be used when the installation mode is set to ``python-package``
 
 versions_to_keep
 ----------------
@@ -32,15 +32,17 @@ 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``
-
 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
 ---------
@@ -98,7 +101,7 @@ Host Configuration
 
 ip
 ~~
-The IP address or hostname of the remote host.
+The IP address or anything that resolves to the remote host IP's. This is use to communicate via ssh with the server, if omitted it's value will default to the one of the ``domain_name``.
 
 domain_name
 ~~~~~~~~~~~
@@ -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
@@ -223,7 +234,7 @@ class Config(msgspec.Struct, kw_only=True):
 
 
 class HostConfig(msgspec.Struct, kw_only=True):
-    ip: str
+    ip: str | None = None
     domain_name: str
     user: str
     _envfile: str = msgspec.field(name="envfile")
@@ -234,6 +245,7 @@ class HostConfig(msgspec.Struct, kw_only=True):
 
     def __post_init__(self):
         self.apps_dir = f"/home/{self.user}/{self.apps_dir}"
+        self.ip = self.ip or self.domain_name
 
     def to_dict(self):
         d = {f: getattr(self, f) for f in self.__struct_fields__}

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/proxies/nginx.py

@@ -35,20 +35,20 @@ class WebProxy(msgspec.Struct):
         )
 
     def run_pty(self, *args, **kwargs):
-        return self.conn.run(*args, **kwargs, pty=True)
+        return self.run_pty(*args, **kwargs, pty=True)
 
     def install(self):
-        self.conn.run(
+        self.run_pty(
             "sudo apt install -y nginx libpq-dev python3-dev python3-certbot-nginx"
         )
 
     def uninstall(self):
         self.stop()
-        self.conn.run("sudo apt remove -y nginx")
-        self.conn.run(f"sudo rm /etc/nginx/sites-available/{self.app_name}.conf")
-        self.conn.run(f"sudo rm /etc/nginx/sites-enabled/{self.app_name}.conf")
-        self.conn.run("sudo systemctl disable certbot.timer")
-        self.conn.run("sudo apt remove -y python3-certbot-nginx")
+        self.run_pty("sudo apt remove -y nginx")
+        self.run_pty(f"sudo rm /etc/nginx/sites-available/{self.app_name}.conf")
+        self.run_pty(f"sudo rm /etc/nginx/sites-enabled/{self.app_name}.conf")
+        self.run_pty("sudo systemctl disable certbot.timer")
+        self.run_pty("sudo apt remove -y python3-certbot-nginx")
 
     def setup(self):
         conf = (
@@ -65,11 +65,11 @@ class WebProxy(msgspec.Struct):
         )
         if CERTBOT_EMAIL:
             cert_path = f"/etc/letsencrypt/live/{self.domain_name}/fullchain.pem"
-            cert_exists = self.conn.run(f"sudo test -f {cert_path}", warn=True).ok
+            cert_exists = self.run_pty(f"sudo test -f {cert_path}", warn=True).ok
 
             if not cert_exists:
-                self.conn.run(
-                    f"certbot --nginx -d {self.domain_name} --non-interactive --agree-tos --email {CERTBOT_EMAIL} --redirect"
+                self.run_pty(
+                    f"sudo certbot --nginx -d {self.domain_name} --non-interactive --agree-tos --email {CERTBOT_EMAIL} --redirect"
                 )
                 self.config_file.parent.mkdir(exist_ok=True)
                 self.conn.get(
@@ -83,9 +83,7 @@ class WebProxy(msgspec.Struct):
     def teardown(self):
         self.run_pty(f"sudo rm /etc/nginx/sites-available/{self.app_name}.conf")
         self.run_pty(f"sudo rm /etc/nginx/sites-enabled/{self.app_name}.conf")
-        self.run_pty(
-            "sudo systemctl restart nginx",
-        )
+        self.run_pty("sudo systemctl restart nginx")
 
     def start(self) -> None:
         self.run_pty("sudo systemctl start nginx")
@@ -109,9 +107,9 @@ class WebProxy(msgspec.Struct):
         static_locations = ""
         for path, directory in self.statics.items():
             static_locations += f"""
-        location {path} {{
-            alias {directory};
-        }}
+    location {path} {{
+        alias {directory};
+    }}
         """
 
         return f"""

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

@@ -1,12 +1,11 @@
 Metadata-Version: 2.3
 Name: fujin-cli
-Version: 0.4.0
-Summary: Add your description here
+Version: 0.6.0
+Summary: Get your project up and running in a few minutes on your own vps.
 Project-URL: Documentation, https://github.com/falcopackages/fujin#readme
 Project-URL: Issues, https://github.com/falcopackages/fujin/issues
 Project-URL: Source, https://github.com/falcopackages/fujin
 Author-email: Tobi DEGNON <tobidegnon@proton.me>
-License-File: LICENSE.txt
 Keywords: caddy,deployment,django,fastapi,litestar,python,systemd
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -37,16 +36,18 @@ Description-Content-Type: text/markdown
 > [!IMPORTANT]
 > This package currently contains minimal features and is a work-in-progress
 
+<!-- content:start -->
+
 `fujin` is a simple deployment tool that helps you get your project up and running on a VPS in a few minutes. It manages your app processes using `systemd` and runs your apps behind [caddy](https://caddyserver.com/). For Python projects, 
 it expects your app to be a packaged Python application ideally with a CLI entry point defined. For other languages, you need to provide a self-contained single executable file with all necessary dependencies.
 The main job of `fujin` is to bootstrap your server (installing caddy, etc.), copy the files onto the server with a structure that supports rollback, and automatically generate configs for systemd and caddy that you can manually edit if needed.
 
-Check out the [documentation📚](https://fujin.readthedocs.io/en/latest/) for installation, features, and usage guides.
+Check out the [documentation📚](https://fujin.oluwatobi.dev/en/latest/) for installation, features, and usage guides.
 
 ## Why?
 
 I wanted [kamal](https://kamal-deploy.org/) but without Docker, and I thought the idea was fun. At its core, this project automates versions of this [tutorial](https://www.digitalocean.com/community/tutorials/how-to-set-up-django-with-postgres-nginx-and-gunicorn-on-ubuntu). If you've been a Django beginner 
-trying to get your app in production, you probably went through this. I'm using caddy instead of nginx because the configuration file simpler and it's is a no-brainer for SSL certificates. Systemd is the default on most Linux distributions and does a good enough job.
+trying to get your app in production, you probably went through this. I'm using caddy instead of nginx because it's configurable via an API and it's is a no-brainer for SSL certificates. Systemd is the default on most Linux distributions and does a good enough job.
 
 Fujin was initially planned to be a Python-only project, but the core concepts can be applied to any language that can produce a single distributable file (e.g., Go, Rust). I wanted to recreate kamal's nice local-to-remote app management API, but I'm skipping Docker to keep things simple. 
 I'm currently rocking SQLite in production for my side projects and ths setup is enough for my use case.
@@ -64,3 +65,5 @@ Fujin draws inspiration from the following tools for their developer experience.
 ## License
 
 `fujin` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
+
+<!-- content:end -->

{fujin_cli-0.4.0.dist-info → fujin_cli-0.6.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=GecU6XklYNXjjR7bkRORBcX1-AYlIaTMw1mmYKSCSnA,9595
 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=t8uwwOi4SBqHjV8px_SkTHAeZIiIUJnFN-lf7DK6HhE,3959
+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/proxies/nginx.py,sha256=S2-tBaytGtehqMyeZZMPSPoXjV1GVv7S63eMtfhkGNM,4100
 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.6.0.dist-info/METADATA,sha256=_rYue3Q7z_StHy_Z9DVdaU0RWijde8eWFlm_gwxN4GY,4452
+fujin_cli-0.6.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+fujin_cli-0.6.0.dist-info/entry_points.txt,sha256=Y_TBtKt3j11qhwquMexZR5yqnDEqOBDACtresqQFE-s,46
+fujin_cli-0.6.0.dist-info/licenses/LICENSE.txt,sha256=0QF8XfuH0zkIHhSet6teXfiCze6JSdr8inRkmLLTDyo,1099
+fujin_cli-0.6.0.dist-info/RECORD,,

{fujin_cli-0.4.0.dist-info → fujin_cli-0.6.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.25.0
+Generator: hatchling 1.26.3
 Root-Is-Purelib: true
 Tag: py3-none-any