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

fujin/proxies/caddy.py

@@ -1,52 +1,217 @@
+from __future__ import annotations
+
 import json
+import urllib.request
+from pathlib import Path
 
 import msgspec
 
 from fujin.config import Config
-from fujin.host import Host
+from fujin.connection import Connection
+
+DEFAULT_VERSION = "2.8.4"
+GH_TAR_FILENAME = "caddy_{version}_linux_amd64.tar.gz"
+GH_DOWNL0AD_URL = (
+    "https://github.com/caddyserver/caddy/releases/download/v{version}/"
+    + GH_TAR_FILENAME
+)
+GH_RELEASE_LATEST_URL = "https://api.github.com/repos/caddyserver/caddy/releases/latest"
+
+
+# TODO: let the user write the configuration with a simple syntax and export use caddy adapter, same for exporting,
+#   don't export to json
 
 
 class WebProxy(msgspec.Struct):
-    host: Host
-    config: Config
+    conn: Connection
+    domain_name: str
+    app_name: str
+    upstream: str
+    statics: dict[str, str]
+    local_config_dir: Path
+
+    @property
+    def config_file(self) -> Path:
+        return self.local_config_dir / "caddy.json"
+
+    @classmethod
+    def create(cls, config: Config, conn: Connection) -> WebProxy:
+        return cls(
+            conn=conn,
+            domain_name=config.host.domain_name,
+            upstream=config.webserver.upstream,
+            app_name=config.app_name,
+            local_config_dir=config.local_config_dir,
+            statics=config.webserver.statics,
+        )
+
+    def run_pty(self, *args, **kwargs):
+        return self.conn.run(*args, **kwargs, pty=True)
 
     def install(self):
-        self.host.run_uv("tool install caddy-bin")
-        self.host.run_caddy("start", pty=True)
+        version = get_latest_gh_tag()
+        download_url = GH_DOWNL0AD_URL.format(version=version)
+        filename = GH_TAR_FILENAME.format(version=version)
+        with self.conn.cd("/tmp"):
+            self.conn.run(f"curl -O -L {download_url}")
+            self.conn.run(f"tar -xzvf {filename}")
+            self.run_pty("sudo mv caddy /usr/bin/")
+            self.conn.run(f"rm {filename}")
+            self.conn.run("rm LICENSE && rm README.md")
+        self.run_pty("sudo groupadd --force --system caddy")
+        self.conn.run(
+            "sudo useradd --system --gid caddy --create-home --home-dir /var/lib/caddy --shell /usr/sbin/nologin --comment 'Caddy web server' caddy",
+            pty=True,
+            warn=True,
+        )
+        self.conn.run(
+            f"echo '{systemd_service}' | sudo tee /etc/systemd/system/caddy-api.service",
+            hide="out",
+            pty=True,
+        )
+        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'""")
+
+    def uninstall(self):
+        self.stop()
+        self.run_pty("sudo systemctl disable caddy-api")
+        self.run_pty("sudo rm /usr/bin/caddy")
+        self.run_pty("sudo rm /etc/systemd/system/caddy-api.service")
+        self.run_pty("sudo userdel caddy")
 
     def setup(self):
-        with self.host.cd_project_dir(self.config.app):
-            self.host.run(f"echo '{json.dumps(self._generate_config())}' > caddy.json")
-            self.host.run(
-                f"curl localhost:2019/load -H 'Content-Type: application/json' -d @caddy.json"
-            )
+        config = (
+            json.loads(self.config_file.read_text())
+            if self.config_file.exists()
+            else self._get_config()
+        )
+        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):
-        # TODO
-        pass
-
-    def _generate_config(self) -> dict:
-        return {
-            "apps": {
-                "http": {
-                    "servers": {
-                        self.config.app: {
-                            "listen": [":443"],
+        self.conn.run(f"echo '{json.dumps({})}' > caddy.json")
+        self.conn.run(
+            f"curl localhost:2019/config/apps/http/servers/{self.app_name} -H 'Content-Type: application/json' -d @caddy.json"
+        )
+
+    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:
+        handle = []
+        config = {
+            "listen": [":443"],
+            "routes": [
+                {
+                    "match": [{"host": [self.domain_name]}],
+                    "handle": handle,
+                }
+            ],
+        }
+        reverse_proxy = {
+            "handler": "reverse_proxy",
+            "upstreams": [{"dial": self.upstream}],
+        }
+        if not self.statics:
+            handle.append(reverse_proxy)
+            return config
+        routes = []
+        handle.append({"handler": "subroute", "routes": 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(
+                {
+                    "handle": [
+                        {
+                            "handler": "subroute",
                             "routes": [
                                 {
-                                    "match": [{"host": [self.host.config.domain_name]}],
                                     "handle": [
                                         {
-                                            "handler": "reverse_proxy",
-                                            "upstreams": [
-                                                {"dial": self.config.webserver.upstream}
-                                            ],
+                                            "handler": "rewrite",
+                                            "strip_path_prefix": strip_path_prefix,
                                         }
-                                    ],
-                                }
+                                    ]
+                                },
+                                {
+                                    "handle": [
+                                        {"handler": "vars", "root": directory},
+                                        {
+                                            "handler": "file_server",
+                                        },
+                                    ]
+                                },
                             ],
                         }
-                    }
+                    ],
+                    "match": [{"path": [path]}],
                 }
-            }
-        }
+            )
+        routes.append({"handle": [reverse_proxy]})
+        return config
+
+
+def get_latest_gh_tag() -> str:
+    with urllib.request.urlopen(GH_RELEASE_LATEST_URL) as response:
+        if response.status != 200:
+            return DEFAULT_VERSION
+        try:
+            data = json.loads(response.read().decode())
+            return data["tag_name"][1:]
+        except (KeyError, json.JSONDecodeError):
+            return DEFAULT_VERSION
+
+
+systemd_service = """
+# caddy-api.service
+#
+# For using Caddy with its API.
+#
+# This unit is "durable" in that it will automatically resume
+# the last active configuration if the service is restarted.
+#
+# See https://caddyserver.com/docs/install for instructions.
+
+[Unit]
+Description=Caddy
+Documentation=https://caddyserver.com/docs/
+After=network.target network-online.target
+Requires=network-online.target
+
+[Service]
+Type=notify
+User=caddy
+Group=www-data
+ExecStart=/usr/bin/caddy run --environ --resume
+TimeoutStopSec=5s
+LimitNOFILE=1048576
+PrivateTmp=true
+ProtectSystem=full
+AmbientCapabilities=CAP_NET_ADMIN CAP_NET_BIND_SERVICE
+
+[Install]
+WantedBy=multi-user.target
+"""

fujin/proxies/dummy.py

@@ -1,16 +1,29 @@
+from __future__ import annotations
+
+from pathlib import Path
+
 from fujin.config import Config
-from fujin.host import Host
+from fujin.connection import Connection
 
 
 class WebProxy:
-    host: Host
-    config: Config
+    config_file: Path
+
+    @classmethod
+    def create(cls, _: Config, __: Connection) -> WebProxy:
+        return cls()
 
     def install(self):
         pass
 
+    def uninstall(self):
+        pass
+
     def setup(self):
         pass
 
     def teardown(self):
         pass
+
+    def export_config(self):
+        pass

fujin/proxies/nginx.py

@@ -1,59 +1,132 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
 import msgspec
 
 from fujin.config import Config
-from fujin.host import Host
-
-CERTBOT_EMAIL = ""
+from fujin.connection import Connection
 
-# TODO: this is a wip
+CERTBOT_EMAIL = os.getenv("CERTBOT_EMAIL")
 
 
 class WebProxy(msgspec.Struct):
-    host: Host
-    config: Config
+    conn: Connection
+    domain_name: str
+    app_name: str
+    upstream: str
+    statics: dict[str, str]
+    local_config_dir: Path
+
+    @property
+    def config_file(self) -> Path:
+        return self.local_config_dir / f"{self.app_name}.conf"
+
+    @classmethod
+    def create(cls, config: Config, conn: Connection) -> WebProxy:
+        return cls(
+            conn=conn,
+            domain_name=config.host.domain_name,
+            upstream=config.webserver.upstream,
+            app_name=config.app_name,
+            local_config_dir=config.local_config_dir,
+            statics=config.webserver.statics,
+        )
+
+    def run_pty(self, *args, **kwargs):
+        return self.conn.run(*args, **kwargs, pty=True)
 
     def install(self):
-        # TODO: won"t always install the latest version, install certbot with uv ?
-        self.host.sudo(
-            "apt install -y nginx libpq-dev python3-dev python3-certbot-nginx sqlite3"
+        self.conn.run(
+            "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")
+
     def setup(self):
-        self.host.sudo(
-            f"echo '{self._get_config()}' | sudo tee /etc/nginx/sites-available/{self.config.app}",
-            hide="out",
+        conf = (
+            self.config_file.read_text()
+            if self.config_file.exists()
+            else self._get_config()
         )
-        self.host.sudo(
-            f"ln -sf /etc/nginx/sites-available/{self.config.app} /etc/nginx/sites-enabled/{self.config.app}"
-        )
-        self.host.sudo(
-            f"certbot --nginx -d {self.host.config.domain_name} --non-interactive --agree-tos --email {CERTBOT_EMAIL} --redirect"
+        self.run_pty(
+            f"sudo echo '{conf}' | sudo tee /etc/nginx/sites-available/{self.app_name}.conf",
+            hide="out",
         )
-        # Updating local Nginx configuration
-        self.host.get(
-            f"/etc/nginx/sites-available/{self.config.app}",
-            f".fujin/{self.config.app}",
+        self.run_pty(
+            f"sudo ln -sf /etc/nginx/sites-available/{self.app_name}.conf /etc/nginx/sites-enabled/{self.app_name}.conf",
         )
-        # Enabling certificate auto-renewal
-        self.host.sudo("systemctl enable certbot.timer")
-        self.host.sudo("systemctl start certbot.timer")
+        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
+
+            if not cert_exists:
+                self.conn.run(
+                    f"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(
+                    f"/etc/nginx/sites-available/{self.app_name}.conf",
+                    str(self.config_file),
+                )
+                self.run_pty("sudo systemctl enable certbot.timer")
+                self.run_pty("sudo systemctl start certbot.timer")
+        self.restart()
 
     def teardown(self):
-        pass
+        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",
+        )
+
+    def start(self) -> None:
+        self.run_pty("sudo systemctl start nginx")
+
+    def stop(self) -> None:
+        self.run_pty("sudo systemctl stop nginx")
+
+    def status(self) -> None:
+        self.run_pty("sudo systemctl status nginx", warn=True)
+
+    def restart(self) -> None:
+        self.run_pty("sudo systemctl restart nginx")
+
+    def logs(self) -> None:
+        self.run_pty(f"sudo journalctl -u nginx -f", warn=True)
+
+    def export_config(self) -> None:
+        self.config_file.write_text(self._get_config())
 
     def _get_config(self) -> str:
+        static_locations = ""
+        for path, directory in self.statics.items():
+            static_locations += f"""
+        location {path} {{
+            alias {directory};
+        }}
+        """
+
         return f"""
 server {{
-   listen 80;
-   server_name {self.host.config.domain_name};
-
-   location / {{
-      proxy_pass {self.config.webserver.upstream};
-      proxy_set_header Host $host;
-      proxy_set_header X-Real-IP $remote_addr;
-      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-      proxy_set_header X-Forwarded-Proto $scheme;
-   }}
-}}
+    listen 80;
+    server_name {self.domain_name};
 
+    {static_locations}
+
+    location / {{
+        proxy_pass {self.upstream};
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }}
+}}
 """

fujin/templates/simple.service

@@ -0,0 +1,14 @@
+# All options are documented here https://www.freedesktop.org/software/systemd/man/latest/systemd.exec.html
+[Unit]
+Description={app_name} Worker
+
+[Service]
+User={user}
+Group={user}
+WorkingDirectory={app_dir}
+ExecStart={app_dir}/{command}
+EnvironmentFile={app_dir}/.env
+Restart=always
+
+[Install]
+WantedBy=multi-user.target

fujin/templates/web.service

@@ -1,24 +1,25 @@
-# TODO: add tons of comments in this file
+# All options are documented here https://www.freedesktop.org/software/systemd/man/latest/systemd.exec.html
+# Inspiration was taken from here https://docs.gunicorn.org/en/stable/deploy.html#systemd
 [Unit]
-Description={app} daemon
-Requires={app}.socket
+Description={app_name} daemon
+Requires={app_name}.socket
 After=network.target
 
 [Service]
-Type=notify
-NotifyAccess=main
+#Type=notify
+#NotifyAccess=main
 User={user}
-Group=www-data
-RuntimeDirectory={app}
-WorkingDirectory={project_dir}
-ExecStart={project_dir}/{command}
-EnvironmentFile={project_dir}/.env
+Group={user}
+RuntimeDirectory={app_name}
+WorkingDirectory={app_dir}
+ExecStart={app_dir}/{command}
+EnvironmentFile={app_dir}/.env
 ExecReload=/bin/kill -s HUP $MAINPID
 KillMode=mixed
 TimeoutStopSec=5
 PrivateTmp=true
 # if your app does not need administrative capabilities, let systemd know
-# ProtectSystem=strict
+ProtectSystem=strict
 
 [Install]
 WantedBy=multi-user.target

fujin/templates/web.socket

@@ -1,8 +1,8 @@
 [Unit]
-Description={app} socket
+Description={app_name} socket
 
 [Socket]
-ListenStream=/run/{app}.sock
+ListenStream=/run/{app_name}.sock
 SocketUser=www-data
 SocketGroup=www-data
 SocketMode=0660

fujin_cli-0.4.0.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.3
+Name: fujin-cli
+Version: 0.4.0
+Summary: Add your description here
+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
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.10
+Requires-Dist: cappa>=0.24
+Requires-Dist: fabric>=3.2.2
+Requires-Dist: msgspec[toml]>=0.18.6
+Requires-Dist: rich>=13.9.2
+Description-Content-Type: text/markdown
+
+# fujin
+
+[![PyPI - Version](https://img.shields.io/pypi/v/fujin-cli.svg)](https://pypi.org/project/fujin-cli)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/fujin-cli.svg)](https://pypi.org/project/fujin-cli)
+[![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/falcopackages/fujin/blob/main/LICENSE.txt)
+[![Status](https://img.shields.io/pypi/status/fujin-cli.svg)](https://pypi.org/project/fujin-cli)
+-----
+
+> [!IMPORTANT]
+> This package currently contains minimal features and is a work-in-progress
+
+`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.
+
+## 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.
+
+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.
+
+The goal is to automate deployment while leaving you in full control of your Linux box. It's not a CLI PaaS - it's simple and expects you to be able to SSH into your server and troubleshoot if necessary. For beginners, it makes the initial deployment easier while you get your hands dirty with Linux.
+If you need a never-break, worry-free, set-it-and-forget-it setup that auto-scales and does all the magic, fujin probably isn't for you.
+
+## Inspiration and alternatives
+
+Fujin draws inspiration from the following tools for their developer experience. These are better alternatives if you need a more robust, set-and-forget solution
+
+- [fly.io](https://fly.io/)
+- [kamal](https://kamal-deploy.org/) (you probably can't just forget this one)
+
+## License
+
+`fujin` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

fujin_cli-0.4.0.dist-info/RECORD

@@ -0,0 +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/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/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/prune.py,sha256=C2aAN6AUS84jgRg1eiCroyiuZyaZDmf5yvGAQY9xkcg,1517
+fujin/commands/redeploy.py,sha256=suSr6S54oLsnKGjJgq3uHxCRFcrCX5C-5BkmH5MzQks,1864
+fujin/commands/rollback.py,sha256=BN9vOTEBcSSpFIfck9nzWvMVO7asVC20lQbcNrxRchg,2009
+fujin/commands/secrets.py,sha256=1xZQVkvbopsAcWUocLstxPKxsvmGoE2jWip5hdTrP50,162
+fujin/commands/server.py,sha256=n0FZbNI4IO5AOMJTIVfJqgb32-QSrWEu0IVwfREsRbY,3637
+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/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,,