shipit-deploy 0.2.0__py3-none-any.whl

shipit/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

shipit/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

shipit/cli.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+import tomllib
+from pathlib import Path
+
+from . import __version__
+from .config import LiveConfig, load
+from .deploy import Deployer
+from .detect import detect
+from .easy import app_name_from_repo, append_app, default_branch, free_port, get_secret, webhook_secret
+from .proxy import sync as _proxy_sync
+
+def resync_proxy(cfg) -> None:
+    """Re-apply Caddy routes at startup (e.g. after Caddy restarted)."""
+    if not any(a.domain for a in cfg.apps.values()):
+        return
+    try:
+        _proxy_sync(cfg, {n: Deployer(a, cfg.state_dir).state() for n, a in cfg.apps.items()})
+    except OSError as e:
+        print(f"[shipit] warning: could not sync Caddy: {e}", file=sys.stderr)
+
+
+SAMPLE = '''[server]
+port = 9000
+state_dir = ".shipit"
+
+[[app]]
+name = "myapp"
+repo = "https://github.com/you/myapp.git"
+branch = "main"
+port = 8080          # port inside the container
+host_port = 8080     # port on this machine
+health_path = "/"
+# token_env  = "GIT_TOKEN"        # private repos
+# secret_env = "MYAPP_SECRET"     # webhook secret (default: SHIPIT_SECRET)
+# notify_env = "SLACK_URL"        # env var with a Slack/Discord webhook URL
+# pre_deploy = "python manage.py migrate"   # runs in the new image before release
+# domain = "app.example.com"   # zero-downtime via Caddy (blue/green on host_port and host_port+1)
+# keep_images = 5
+# env_file   = "/etc/myapp.env"
+# start      = "gunicorn app:app -b 0.0.0.0:8080"
+'''
+
+
+def cmd_up(a) -> int:
+    """Zero-config: register a repo, deploy it now, and explain how to enable auto deploy."""
+    path = Path(a.config)
+    raw = tomllib.loads(path.read_text(encoding="utf-8")) if path.exists() else {}
+    existing = raw.get("app", [])
+    name = a.name or app_name_from_repo(a.repo)
+    if any(x["name"] == name for x in existing):
+        print(f"app {name!r} already exists - redeploy it with: shipit deploy {name}", file=sys.stderr)
+        return 2
+    taken = {p for x in existing for p in (x.get("host_port", 8080), x.get("host_port", 8080) + 1)}
+    host_port = free_port(taken)
+    fields = {"name": name, "repo": a.repo, "branch": a.branch or default_branch(a.repo),
+              "port": a.port, "host_port": host_port, "domain": a.domain}
+    append_app(path, fields)
+    cfg = load(path)
+    print(f"[shipit] added {name!r} to {path} (branch {fields['branch']}, port {host_port})", flush=True)
+    ok = Deployer(cfg.apps[name], cfg.state_dir, cfg).deploy()
+    if not ok:
+        print(f"\nDeploy failed. Fix the problem, then retry with: shipit deploy {name}", file=sys.stderr)
+        return 1
+    url = f"https://{a.domain}" if a.domain else f"http://localhost:{host_port}"
+    print(f"\n{name} is live: {url}\n")
+    print("Turn on auto deploy (every push to the branch redeploys):")
+    print("  1. run:  shipit serve")
+    print(f"  2. GitHub repos, automatic:  shipit hook {name} --url http://<this-server>:{cfg.listen_port}")
+    print(f"     or by hand: Settings -> Webhooks -> http://<this-server>:{cfg.listen_port}/hook/{name}")
+    print(f"     content type: application/json     secret: {get_secret(cfg.state_dir)}")
+    return 0
+
+
+def cmd_hook(a, cfg) -> int:
+    """Register the GitHub webhook for an app (needs the `gh` CLI, logged in)."""
+    from . import hooks
+    app = cfg.apps[a.app]
+    url = hooks.hook_url(a.url, app.name)
+    secret = webhook_secret(app, cfg.state_dir)
+    try:
+        result = hooks.register(app.repo, url, secret)
+    except (ValueError, RuntimeError, OSError) as e:
+        print(f"could not register automatically: {e}", file=sys.stderr)
+        print(f"Add it by hand: URL {url}, content type application/json, secret: {secret}", file=sys.stderr)
+        return 1
+    print(f"webhook {result}: pushes to {app.branch} will now redeploy {app.name} ({url})")
+    return 0
+
+
+def cmd_list(cfg) -> int:
+    for app in cfg.apps.values():
+        d = Deployer(app, cfg.state_dir, cfg)
+        url = f"https://{app.domain}" if app.domain else f"http://localhost:{app.host_port}"
+        state = "running" if d._running(d._live_name()) else "stopped"
+        print(f"{app.name:<20} {state:<8} {url:<34} {d.state().get('current', '-')}")
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(prog="shipit", description="Self-hosted auto deploy for any language.")
+    p.add_argument("--version", action="version", version=__version__)
+    p.add_argument("-c", "--config", default=os.environ.get("SHIPIT_CONFIG", "shipit.toml"))
+    sub = p.add_subparsers(dest="cmd", required=True)
+    sub.add_parser("init", help="write a sample shipit.toml")
+    d = sub.add_parser("detect", help="show detected language / print generated Dockerfile")
+    d.add_argument("path", nargs="?", default=".")
+    d.add_argument("--port", type=int, default=8080)
+    for name, h in (("deploy", "deploy an app now"), ("rollback", "roll back to previous release")):
+        s = sub.add_parser(name, help=h)
+        s.add_argument("app")
+    st = sub.add_parser("status", help="show current release and recent history")
+    st.add_argument("app")
+    lg = sub.add_parser("logs", help="show container logs")
+    lg.add_argument("app")
+    lg.add_argument("-n", "--tail", type=int, default=100)
+    lg.add_argument("-f", "--follow", action="store_true")
+    sub.add_parser("doctor", help="check docker/git/caddy/secrets before deploying")
+    up = sub.add_parser("up", help="zero-config: deploy a git repo right now")
+    up.add_argument("repo", help="git URL of the project")
+    up.add_argument("--name")
+    up.add_argument("--branch", help="default: the repo's default branch")
+    up.add_argument("--port", type=int, help="port the app listens on in the container (usually auto-detected)")
+    up.add_argument("--domain", help="serve at this domain via Caddy with zero-downtime releases")
+    hk = sub.add_parser("hook", help="register the GitHub push webhook for an app (uses gh)")
+    hk.add_argument("app")
+    hk.add_argument("--url", required=True, help="public URL of this server, e.g. https://deploy.example.com or http://1.2.3.4:9000")
+    sub.add_parser("list", help="list apps and their status")
+    sub.add_parser("serve", help="run the webhook server")
+    a = p.parse_args(argv)
+
+    try:
+        if a.cmd == "up":
+            return cmd_up(a)
+        if a.cmd == "init":
+            f = Path(a.config)
+            if f.exists():
+                print(f"{f} already exists", file=sys.stderr)
+                return 1
+            f.write_text(SAMPLE, encoding="utf-8")
+            print(f"wrote {f}")
+            return 0
+        if a.cmd == "detect":
+            r = detect(a.path, a.port)
+            print(f"# language: {r.lang}\n{r.dockerfile}")
+            return 0
+        cfg = load(a.config)
+        if a.cmd == "hook":
+            if a.app not in cfg.apps:
+                print(f"unknown app {a.app!r}; known: {', '.join(cfg.apps)}", file=sys.stderr)
+                return 2
+            return cmd_hook(a, cfg)
+        if a.cmd == "list":
+            return cmd_list(cfg)
+        if a.cmd == "doctor":
+            from . import doctor
+            return doctor.run(cfg)
+        if a.cmd == "serve":
+            from .webhook import make_server
+            resync_proxy(cfg)
+            srv = make_server(LiveConfig(a.config))
+            print(f"[shipit] listening on {cfg.listen_host}:{cfg.listen_port}  (POST /hook/<app>)", flush=True)
+            try:
+                srv.serve_forever()
+            except KeyboardInterrupt:
+                pass
+            return 0
+        if a.app not in cfg.apps:
+            print(f"unknown app {a.app!r}; known: {', '.join(cfg.apps)}", file=sys.stderr)
+            return 2
+        dep = Deployer(cfg.apps[a.app], cfg.state_dir, cfg)
+        if a.cmd == "status":
+            print(dep.status())
+            return 0
+        if a.cmd == "logs":
+            dep.logs(a.tail, a.follow)
+            return 0
+        ok = dep.deploy() if a.cmd == "deploy" else dep.rollback()
+        return 0 if ok else 1
+    except (ValueError, OSError) as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

shipit/config.py

@@ -0,0 +1,90 @@
+"""Load shipit.toml."""
+from __future__ import annotations
+
+import re
+import threading
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+
+DOMAIN_RE = re.compile(r"^[A-Za-z0-9]([A-Za-z0-9.-]{0,251}[A-Za-z0-9])?$")
+NAME_RE = re.compile(r"^[a-z0-9][a-z0-9_.-]{0,62}$")
+
+
+@dataclass
+class App:
+    name: str
+    repo: str
+    branch: str = "main"
+    port: int = 8080              # port the app listens on inside the container
+    host_port: int = 8080         # port published on this machine
+    health_path: str = "/"        # HTTP path polled after start; "" = just check container is running
+    health_timeout: int = 60
+    start: str | None = None      # override start command (used by generated Dockerfiles)
+    dockerfile: str | None = None # path inside repo; default: ./Dockerfile, else auto-generated
+    env_file: str | None = None   # path on the host
+    token_env: str | None = None  # env var holding a git token for private https repos
+    secret_env: str | None = None # env var with the webhook secret for this app
+    pre_deploy: str | None = None # command run once in the new image before release (e.g. migrations); failure aborts
+    domain: str | None = None     # set to serve via Caddy with zero-downtime blue/green (needs Caddy)
+    notify_env: str | None = None # env var holding a Slack/Discord/Mattermost-style webhook URL
+    drain_seconds: int = 5        # proxy mode: wait before removing the old slot
+    keep_images: int = 5          # old images kept on disk (current + previous are always kept)
+    build_args: dict[str, str] = field(default_factory=dict)
+
+
+@dataclass
+class Config:
+    state_dir: Path
+    listen_host: str
+    listen_port: int
+    caddy_admin: str
+    apps: dict[str, App]
+
+
+def load(path: str | Path) -> Config:
+    data = tomllib.loads(Path(path).read_text(encoding="utf-8"))
+    server = data.get("server", {})
+    apps: dict[str, App] = {}
+    for raw in data.get("app", []):
+        app = App(**raw)
+        if not NAME_RE.match(app.name):
+            raise ValueError(f"invalid app name {app.name!r} (use a-z 0-9 _ . -)")
+        if app.domain and not DOMAIN_RE.match(app.domain):
+            raise ValueError(f"invalid domain {app.domain!r}")
+        if app.name in apps:
+            raise ValueError(f"duplicate app {app.name!r}")
+        apps[app.name] = app
+    if not apps:
+        raise ValueError("no [[app]] entries in config")
+    return Config(
+        # relative state_dir is relative to the config file, not the current directory
+        state_dir=(Path(path).resolve().parent / server.get("state_dir", ".shipit")).resolve(),
+        listen_host=server.get("host", "0.0.0.0"),
+        listen_port=int(server.get("port", 9000)),
+        caddy_admin=server.get("caddy_admin", "http://127.0.0.1:2019"),
+        apps=apps,
+    )
+
+
+class LiveConfig:
+    """Re-reads the config file when it changes, so `shipit up` can add apps while `serve` runs."""
+
+    def __init__(self, path: str | Path):
+        self.path = Path(path)
+        self._mtime: int | None = None
+        self._cfg: Config | None = None
+        self._lock = threading.Lock()
+        self.get()
+
+    def get(self) -> Config:
+        with self._lock:
+            try:
+                mtime = self.path.stat().st_mtime_ns
+                if mtime != self._mtime:
+                    self._cfg = load(self.path)
+                    self._mtime = mtime
+            except (OSError, ValueError):
+                if self._cfg is None:
+                    raise  # first load must succeed; later bad edits keep the last good config
+            return self._cfg

shipit/deploy.py

@@ -0,0 +1,327 @@
+"""Build and run an app with Docker, health-check it, roll back on failure."""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+from urllib.parse import urlparse, urlunparse
+
+from . import proxy
+from .config import App, Config
+from .detect import detect
+
+
+def log(msg: str) -> None:
+    print(f"[shipit] {msg}", flush=True)
+
+
+def run(cmd: list[str], cwd: Path | None = None, check: bool = True) -> subprocess.CompletedProcess:
+    safe = " ".join(cmd)
+    log(f"$ {safe[:200]}")
+    return subprocess.run(cmd, cwd=cwd, check=check, text=True)
+
+
+def _out(cmd: list[str], cwd: Path | None = None) -> str:
+    return subprocess.run(cmd, cwd=cwd, check=True, text=True, capture_output=True).stdout.strip()
+
+
+def _auth_url(app: App) -> str:
+    """Inject a token into an https repo URL without writing it to disk or logs."""
+    token = os.environ.get(app.token_env) if app.token_env else None
+    u = urlparse(app.repo)
+    if token and u.scheme in ("http", "https"):
+        return urlunparse(u._replace(netloc=f"x-access-token:{token}@{u.hostname}" + (f":{u.port}" if u.port else "")))
+    return app.repo
+
+
+class Deployer:
+    def __init__(self, app: App, state_dir: Path, cfg: Config | None = None):
+        self.app = app
+        self.cfg = cfg
+        self.state_dir = state_dir
+        self._port: int | None = None  # container port of the image being built
+        self.dir = state_dir / app.name
+        self.src = self.dir / "src"
+        self.state_file = self.dir / "state.json"
+        self.dir.mkdir(parents=True, exist_ok=True)
+
+    # ---- state -------------------------------------------------------
+    def state(self) -> dict:
+        try:
+            return json.loads(self.state_file.read_text())
+        except (OSError, ValueError):
+            return {}
+
+    def _save(self, **kw) -> None:
+        s = self.state()
+        s.update(kw)
+        self.state_file.write_text(json.dumps(s, indent=2))
+
+    @property
+    def container_port(self) -> int:
+        """Port the app listens on inside the container (generated Dockerfiles may differ from config)."""
+        return self._port or self.state().get("container_port") or self.app.port
+
+    # ---- steps -------------------------------------------------------
+    def sync(self) -> str:
+        a = self.app
+        url = _auth_url(a)
+        if (self.src / ".git").exists():
+            run(["git", "remote", "set-url", "origin", url], cwd=self.src)
+            run(["git", "fetch", "--depth", "1", "origin", a.branch], cwd=self.src)
+            run(["git", "reset", "--hard", "FETCH_HEAD"], cwd=self.src)
+            run(["git", "clean", "-fdx"], cwd=self.src)
+        else:
+            run(["git", "clone", "--depth", "1", "-b", a.branch, url, str(self.src)])
+        run(["git", "remote", "set-url", "origin", a.repo], cwd=self.src)  # drop token from .git/config
+        return _out(["git", "rev-parse", "--short=12", "HEAD"], cwd=self.src)
+
+    def build(self, sha: str) -> str:
+        a = self.app
+        image = f"shipit/{a.name}:{sha}"
+        dockerfile = self.src / (a.dockerfile or "Dockerfile")
+        self._port = a.port  # a repo-provided Dockerfile listens where the config says
+        generated = not dockerfile.exists()
+        if generated:
+            d = detect(self.src, a.port, a.start)
+            self._port = d.port
+            log(f"detected {d.lang}; generating Dockerfile")
+            dockerfile = self.dir / "Dockerfile.generated"
+            dockerfile.write_text(d.dockerfile)
+        cmd = ["docker", "build", "-f", str(dockerfile), "-t", image]
+        for k, v in a.build_args.items():
+            cmd += ["--build-arg", f"{k}={v}"]
+        run(cmd + [str(self.src)])
+        if not generated:
+            exposed = self._exposed_ports(image)
+            if len(exposed) == 1:   # zero-config: follow the Dockerfile's EXPOSE
+                self._port = exposed[0]
+        return image
+
+    @staticmethod
+    def _exposed_ports(image: str) -> list[int]:
+        try:
+            data = json.loads(_out(["docker", "image", "inspect", "-f", "{{json .Config.ExposedPorts}}", image]))
+        except (subprocess.CalledProcessError, ValueError):
+            return []
+        return sorted(int(k.split("/")[0]) for k in (data or {}))
+
+    def _run_container(self, name: str, image: str, publish: str, restart: str = "unless-stopped") -> None:
+        a = self.app
+        run(["docker", "rm", "-f", name], check=False)
+        cmd = ["docker", "run", "-d", "--name", name, "--restart", restart,
+               "-p", publish, "--label", "shipit=1"]
+        if a.env_file:
+            cmd += ["--env-file", a.env_file]
+        run(cmd + [image])
+
+    def _pre_deploy(self, image: str) -> bool:
+        a = self.app
+        if not a.pre_deploy:
+            return True
+        cmd = ["docker", "run", "--rm"] + (["--env-file", a.env_file] if a.env_file else [])
+        ok = run(cmd + [image, "sh", "-c", a.pre_deploy], check=False).returncode == 0
+        if not ok:
+            log("pre_deploy command failed; release aborted")
+            self._record("pre-deploy-failed", image)
+            self.notify(f"❌ {a.name}: pre_deploy failed for {image}. The live version is unchanged.")
+        return ok
+
+    def start(self, image: str) -> None:
+        a = self.app
+        self._run_container(a.name, image, f"{a.host_port}:{self.container_port}")
+
+    def _running(self, name: str) -> bool:
+        r = subprocess.run(["docker", "inspect", "-f", "{{.State.Running}}", name],
+                           capture_output=True, text=True)
+        return r.stdout.strip() == "true"
+
+    def healthy(self, name: str | None = None, host_port: int | None = None) -> bool:
+        a = self.app
+        name = name or a.name
+        host_port = host_port or a.host_port
+        deadline = time.time() + a.health_timeout
+        while time.time() < deadline:
+            if not self._running(name):
+                return False
+            if not a.health_path:
+                time.sleep(5)  # no HTTP check: require it to survive a few seconds
+                return self._running(name)
+            try:
+                with urllib.request.urlopen(f"http://127.0.0.1:{host_port}{a.health_path}", timeout=3) as r:
+                    if r.status < 500:
+                        return True
+            except urllib.error.HTTPError as e:
+                if e.code < 500:
+                    return True
+            except OSError:
+                pass
+            time.sleep(2)
+        return False
+
+    # ---- history / notify / prune -----------------------------------
+    def _record(self, status: str, image: str) -> None:
+        hist = self.state().get("history", [])
+        hist.append({"time": time.strftime("%Y-%m-%d %H:%M:%S"), "image": image, "status": status})
+        self._save(history=hist[-20:])
+
+    def notify(self, text: str) -> None:
+        env = self.app.notify_env
+        url = os.environ.get(env) if env else None
+        if not url or urlparse(url).scheme not in ("http", "https"):
+            return
+        # "text" works for Slack/Mattermost, "content" for Discord.
+        body = json.dumps({"text": text, "content": text}).encode()
+        req = urllib.request.Request(url, data=body, headers={"Content-Type": "application/json"})
+        try:
+            urllib.request.urlopen(req, timeout=10).close()
+        except OSError as e:
+            log(f"notify failed: {e}")
+
+    def prune(self) -> None:
+        s = self.state()
+        keep = {i for i in (s.get("current"), s.get("previous")) if i}
+        out = subprocess.run(["docker", "images", f"shipit/{self.app.name}", "--format", "{{.Repository}}:{{.Tag}}"],
+                             capture_output=True, text=True).stdout.split()
+        for image in out[max(self.app.keep_images, 0):]:  # docker lists newest first
+            if image not in keep:
+                run(["docker", "rmi", image], check=False)
+
+    # ---- zero-downtime release through Caddy ------------------------
+    def _all_states(self) -> dict[str, dict]:
+        return {n: Deployer(a, self.state_dir).state() for n, a in self.cfg.apps.items()}
+
+    def _release_proxy(self, image: str, prev: str | None) -> bool:
+        a = self.app
+        if self.cfg is None:
+            raise ValueError("`domain` needs the full config; run via the shipit CLI")
+        old = self.state()
+        old_slot = old.get("slot")
+        new_slot = "green" if old_slot == "blue" else "blue"
+        port = proxy.slot_port(a.host_port, new_slot)
+        name = f"{a.name}-{new_slot}"
+        self._run_container(name, image, f"127.0.0.1:{port}:{self.container_port}")
+        if not self.healthy(name, port):
+            log(f"health check FAILED for {image}; live version untouched")
+            run(["docker", "logs", "--tail", "40", name], check=False)
+            run(["docker", "rm", "-f", name], check=False)
+            self._record("failed", image)
+            self.notify(f"❌ {a.name}: {image} failed its health check. The live version is unchanged.")
+            return False
+        self._save(slot=new_slot, port=port, current=image, previous=prev, container_port=self.container_port)
+        try:
+            proxy.sync(self.cfg, self._all_states())
+        except OSError as e:
+            log(f"Caddy update failed ({e}); keeping the old version")
+            self._save(**{k: old.get(k) for k in ("slot", "port", "current", "previous")})
+            run(["docker", "rm", "-f", name], check=False)
+            self._record("proxy-failed", image)
+            self.notify(f"❌ {a.name}: could not update Caddy ({e}). The live version is unchanged.")
+            return False
+        if old_slot:
+            time.sleep(a.drain_seconds)  # let in-flight requests finish
+            run(["docker", "rm", "-f", f"{a.name}-{old_slot}"], check=False)
+        return True
+
+    # ---- public ------------------------------------------------------
+    def deploy(self) -> bool:
+        a = self.app
+        log(f"deploying {a.name} ({a.repo}@{a.branch})")
+        try:
+            sha = self.sync()
+            image = self.build(sha)
+        except Exception as e:
+            self._record("build-failed", "-")
+            self.notify(f"❌ {a.name}: build failed ({e})")
+            raise
+        if not self._pre_deploy(image):
+            return False
+        prev = self.state().get("current")
+        if a.domain:
+            ok = self._release_proxy(image, prev)
+            if ok:
+                self._record("deployed", image)
+                self.notify(f"✅ {a.name} deployed: {image} (zero-downtime)")
+                self.prune()
+                log(f"OK {a.name} -> {image}")
+            return ok
+
+        # 1. Start the new version beside the live one on a random local port and test it.
+        cand = f"{a.name}-next"
+        self._run_container(cand, image, f"127.0.0.1::{self.container_port}", restart="no")
+        try:
+            port = int(_out(["docker", "port", cand, f"{self.container_port}/tcp"]).splitlines()[0].rsplit(":", 1)[1])
+            ok = self.healthy(cand, port)
+        except (subprocess.CalledProcessError, IndexError, ValueError):
+            ok = False
+        if not ok:
+            log(f"health check FAILED for {image}; live version untouched")
+            run(["docker", "logs", "--tail", "40", cand], check=False)
+            run(["docker", "rm", "-f", cand], check=False)
+            self._record("failed", image)
+            self.notify(f"❌ {a.name}: {image} failed its health check. The live version is unchanged.")
+            return False
+        run(["docker", "rm", "-f", cand], check=False)
+
+        # 2. Swap (a brief gap while the port is handed over), then verify again.
+        self.start(image)
+        if self.healthy():
+            self._save(current=image, previous=prev, container_port=self.container_port)
+            self._record("deployed", image)
+            self.notify(f"✅ {a.name} deployed: {image}")
+            self.prune()
+            log(f"OK {a.name} -> {image}")
+            return True
+        log("health check failed after swap")
+        run(["docker", "logs", "--tail", "40", a.name], check=False)
+        if prev:
+            log(f"rolling back to {prev}")
+            self.start(prev)
+        else:
+            run(["docker", "rm", "-f", a.name], check=False)
+        self._record("failed-after-swap", image)
+        self.notify(f"❌ {a.name}: {image} failed after swap; rolled back to {prev or 'nothing'}")
+        return False
+
+    def rollback(self) -> bool:
+        prev = self.state().get("previous")
+        if not prev:
+            log("no previous release recorded")
+            return False
+        cur = self.state().get("current")
+        if self.app.domain:
+            ok = self._release_proxy(prev, cur)
+            if ok:
+                self._record("rolled-back", prev)
+                self.notify(f"↩️ {self.app.name} rolled back to {prev}")
+            return ok
+        self.start(prev)
+        if self.healthy():
+            self._save(current=prev, previous=cur)
+            self._record("rolled-back", prev)
+            self.notify(f"↩️ {self.app.name} rolled back to {prev}")
+            log(f"rolled back to {prev}")
+            return True
+        return False
+
+    def _live_name(self) -> str:
+        slot = self.state().get("slot")
+        return f"{self.app.name}-{slot}" if self.app.domain and slot else self.app.name
+
+    def status(self) -> str:
+        s = self.state()
+        lines = [f"app:      {self.app.name}",
+                 f"running:  {'yes' if self._running(self._live_name()) else 'no'}",
+                 f"current:  {s.get('current', '-')}",
+                 f"previous: {s.get('previous', '-')}",
+                 "history:"]
+        lines += [f"  {h['time']}  {h['status']:<18} {h['image']}" for h in s.get("history", [])[-5:]]
+        return "\n".join(lines)
+
+    def logs(self, tail: int = 100, follow: bool = False) -> None:
+        cmd = ["docker", "logs", "--tail", str(tail)] + (["-f"] if follow else []) + [self._live_name()]
+        run(cmd, check=False)