shipit-deploy 0.2.0__tar.gz

shipit_deploy-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 shipit contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

shipit_deploy-0.2.0/PKG-INFO

@@ -0,0 +1,174 @@
+Metadata-Version: 2.4
+Name: shipit-deploy
+Version: 0.2.0
+Summary: Self-hosted, language-agnostic auto deploy: git push -> build -> health check -> rollback
+License: MIT
+Project-URL: Homepage, https://github.com/desnarong/shipit
+Project-URL: Issues, https://github.com/desnarong/shipit/issues
+Project-URL: Changelog, https://github.com/desnarong/shipit/blob/main/CHANGELOG.md
+Keywords: deploy,auto-deploy,docker,ci-cd,self-hosted,webhook,devops
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: System :: Software Distribution
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# 🚢 shipit
+
+[![CI](https://github.com/desnarong/shipit/actions/workflows/ci.yml/badge.svg)](https://github.com/desnarong/shipit/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/shipit-deploy)](https://pypi.org/project/shipit-deploy/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+Self-hosted, open-source auto deploy that works with **any language**.
+`git push` → webhook → clone → build (Docker) → run → health check → **auto rollback** on failure.
+
+- Zero dependencies (Python 3.11+ stdlib only) + Docker + git
+- Auto-detects Node, Python, Go, Rust, Java (Maven/Gradle), PHP, Ruby, .NET, Elixir, static sites
+- Python start command is inferred for Django (gunicorn), FastAPI (uvicorn) and Flask (gunicorn)
+- **Any other language:** put a `Dockerfile` in your repo – it always takes priority
+- GitHub / Gitea / Forgejo (HMAC) and GitLab (token) webhooks
+- Private repos via token from an env var (never written to disk)
+- **Safe deploys:** the new version starts beside the live one and must pass its health check *before* the swap; a bad release never touches production
+- Automatic rollback if it fails right after the swap, or manually with `shipit rollback <app>`
+- Slack / Discord / Mattermost notifications, deploy history, automatic pruning of old images
+- `shipit status <app>` and `shipit logs <app> -f`
+
+## Install on a Linux server (one command)
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/desnarong/shipit/main/install.sh | sudo bash
+```
+
+Installs git, Python and Docker if missing, puts shipit in `/opt/shipit`, creates a `shipit` user and a
+systemd service that listens for webhooks on port 9000. Read the script first if you like - it is short.
+Options: `--dry-run`, `--no-docker`, `--no-service`, `--from-git`.
+
+Then deploy and enable auto deploy:
+
+```bash
+sudo -u shipit SHIPIT_CONFIG=/var/lib/shipit/shipit.toml shipit up https://github.com/you/your-app.git
+shipit hook your-app --url http://YOUR-SERVER-IP:9000      # registers the GitHub webhook for you (needs `gh`)
+```
+
+## Quick start (any machine with Docker)
+
+```bash
+pip install shipit-deploy          # the command is `shipit`
+# or the latest from GitHub: pip install git+https://github.com/desnarong/shipit.git
+shipit up https://github.com/you/your-app.git
+```
+
+That's it. `shipit up` picks the default branch, a free port and the right Dockerfile (or writes one),
+builds, starts the app, health-checks it and prints the URL. No config file to write -
+it creates `shipit.toml` for you. Add `--domain app.example.com` for HTTPS + zero-downtime releases (needs Caddy).
+
+**Turn on auto deploy** (every push redeploys): run `shipit serve`, then register the webhook:
+`shipit hook myapp --url http://YOUR-SERVER:9000` (GitHub, uses the `gh` CLI), or add the URL and secret
+that `shipit up` printed to your repo by hand (Settings -> Webhooks). Apps added with `shipit up`
+are picked up by a running `shipit serve` automatically - no restart.
+
+Other commands:
+
+```bash
+shipit list                  # apps, status, URLs
+shipit hook myapp --url URL  # register the GitHub push webhook
+shipit deploy myapp          # redeploy now
+shipit rollback myapp        # back to the previous release
+shipit logs myapp -f         # follow logs
+shipit status myapp          # current release + history
+shipit doctor                # check docker / git / caddy / secrets
+shipit detect ./my-project   # preview the generated Dockerfile
+```
+
+The webhook secret is generated for you (kept in `.shipit/webhook-secret`); set `SHIPIT_SECRET` to use your own.
+If your Dockerfile has a single `EXPOSE`, shipit uses that port automatically.
+
+Add a webhook in your repo: URL `http://your-server:9000/hook/myapp`, content type
+`application/json`, secret = `SHIPIT_SECRET` (GitLab: put it in "Secret token").
+Only pushes to the configured `branch` deploy.
+
+## Config (`shipit.toml`)
+
+| key | meaning |
+|---|---|
+| `name` | app name (`a-z 0-9 _ . -`), also the container name |
+| `repo`, `branch` | git source |
+| `port` / `host_port` | container port / published port |
+| `health_path` | HTTP path polled after start (`""` = only check it stays running) |
+| `start` | start command for generated Dockerfiles |
+| `dockerfile` | custom Dockerfile path inside the repo |
+| `pre_deploy` | command run once in the new image before release (e.g. `python manage.py migrate`); failure aborts and the live version stays |
+| `env_file` | host env file passed to the container |
+| `token_env` | env var holding a git token (private https repos) |
+| `secret_env` | env var with this app's webhook secret |
+| `notify_env` | env var holding a Slack/Discord/Mattermost webhook URL |
+| `keep_images` | old images to keep (default 5; current + previous always kept) |
+| `build_args` | table of Docker build args |
+
+## Zero-downtime with Caddy
+
+Set `domain` on an app and shipit switches to **blue/green** deploys behind [Caddy](https://caddyserver.com):
+
+```toml
+[server]
+caddy_admin = "http://127.0.0.1:2019"   # default
+
+[[app]]
+name = "myapp"
+domain = "app.example.com"   # DNS must point at this server
+host_port = 9000             # slots use 127.0.0.1:9000 (blue) and :9001 (green)
+```
+
+A release starts the idle slot, waits for its health check, flips the Caddy route, waits
+`drain_seconds`, then removes the old slot - no gap, and HTTPS certificates come from Caddy automatically.
+If the health check or the Caddy update fails, the live version is untouched.
+
+Requirements: Caddy running with its admin API enabled (the default). **shipit owns the Caddy config** -
+it pushes a full config on every release and on `shipit serve` start, so don't hand-edit that Caddy instance.
+Apps without `domain` keep the simple mode (brief swap gap).
+
+## Run it as a service (systemd)
+
+```ini
+[Service]
+Environment=SHIPIT_SECRET=change-me
+WorkingDirectory=/opt/shipit
+ExecStart=/usr/local/bin/shipit serve
+Restart=always
+```
+
+Put nginx/Caddy in front for HTTPS and for routing domains to each app's `host_port`.
+
+## Security notes
+
+- The webhook endpoint rejects anything without a valid signature/token.
+- Deploying runs `docker build` on code from your repo – only point it at repos you trust.
+- Run `shipit serve` behind HTTPS; the host running it controls Docker, so keep it locked down.
+
+## Limitations (v0.1)
+
+Single server, single container per app. Without `domain` there is a brief gap while the port is handed over.
+PRs welcome – ideas: multi-server, PR preview deploys, web UI, Traefik/nginx backends.
+
+## Develop
+
+```bash
+python -m unittest discover -s tests
+```
+
+End-to-end tests deploy real sample apps with Docker (needs Docker + git, takes a few minutes):
+
+```bash
+SHIPIT_E2E=1 python -m unittest tests.test_e2e -v
+```
+
+Contributions welcome - see [CONTRIBUTING.md](CONTRIBUTING.md). Security issues: [SECURITY.md](SECURITY.md). MIT licensed.

shipit_deploy-0.2.0/README.md

@@ -0,0 +1,150 @@
+# 🚢 shipit
+
+[![CI](https://github.com/desnarong/shipit/actions/workflows/ci.yml/badge.svg)](https://github.com/desnarong/shipit/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/shipit-deploy)](https://pypi.org/project/shipit-deploy/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+Self-hosted, open-source auto deploy that works with **any language**.
+`git push` → webhook → clone → build (Docker) → run → health check → **auto rollback** on failure.
+
+- Zero dependencies (Python 3.11+ stdlib only) + Docker + git
+- Auto-detects Node, Python, Go, Rust, Java (Maven/Gradle), PHP, Ruby, .NET, Elixir, static sites
+- Python start command is inferred for Django (gunicorn), FastAPI (uvicorn) and Flask (gunicorn)
+- **Any other language:** put a `Dockerfile` in your repo – it always takes priority
+- GitHub / Gitea / Forgejo (HMAC) and GitLab (token) webhooks
+- Private repos via token from an env var (never written to disk)
+- **Safe deploys:** the new version starts beside the live one and must pass its health check *before* the swap; a bad release never touches production
+- Automatic rollback if it fails right after the swap, or manually with `shipit rollback <app>`
+- Slack / Discord / Mattermost notifications, deploy history, automatic pruning of old images
+- `shipit status <app>` and `shipit logs <app> -f`
+
+## Install on a Linux server (one command)
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/desnarong/shipit/main/install.sh | sudo bash
+```
+
+Installs git, Python and Docker if missing, puts shipit in `/opt/shipit`, creates a `shipit` user and a
+systemd service that listens for webhooks on port 9000. Read the script first if you like - it is short.
+Options: `--dry-run`, `--no-docker`, `--no-service`, `--from-git`.
+
+Then deploy and enable auto deploy:
+
+```bash
+sudo -u shipit SHIPIT_CONFIG=/var/lib/shipit/shipit.toml shipit up https://github.com/you/your-app.git
+shipit hook your-app --url http://YOUR-SERVER-IP:9000      # registers the GitHub webhook for you (needs `gh`)
+```
+
+## Quick start (any machine with Docker)
+
+```bash
+pip install shipit-deploy          # the command is `shipit`
+# or the latest from GitHub: pip install git+https://github.com/desnarong/shipit.git
+shipit up https://github.com/you/your-app.git
+```
+
+That's it. `shipit up` picks the default branch, a free port and the right Dockerfile (or writes one),
+builds, starts the app, health-checks it and prints the URL. No config file to write -
+it creates `shipit.toml` for you. Add `--domain app.example.com` for HTTPS + zero-downtime releases (needs Caddy).
+
+**Turn on auto deploy** (every push redeploys): run `shipit serve`, then register the webhook:
+`shipit hook myapp --url http://YOUR-SERVER:9000` (GitHub, uses the `gh` CLI), or add the URL and secret
+that `shipit up` printed to your repo by hand (Settings -> Webhooks). Apps added with `shipit up`
+are picked up by a running `shipit serve` automatically - no restart.
+
+Other commands:
+
+```bash
+shipit list                  # apps, status, URLs
+shipit hook myapp --url URL  # register the GitHub push webhook
+shipit deploy myapp          # redeploy now
+shipit rollback myapp        # back to the previous release
+shipit logs myapp -f         # follow logs
+shipit status myapp          # current release + history
+shipit doctor                # check docker / git / caddy / secrets
+shipit detect ./my-project   # preview the generated Dockerfile
+```
+
+The webhook secret is generated for you (kept in `.shipit/webhook-secret`); set `SHIPIT_SECRET` to use your own.
+If your Dockerfile has a single `EXPOSE`, shipit uses that port automatically.
+
+Add a webhook in your repo: URL `http://your-server:9000/hook/myapp`, content type
+`application/json`, secret = `SHIPIT_SECRET` (GitLab: put it in "Secret token").
+Only pushes to the configured `branch` deploy.
+
+## Config (`shipit.toml`)
+
+| key | meaning |
+|---|---|
+| `name` | app name (`a-z 0-9 _ . -`), also the container name |
+| `repo`, `branch` | git source |
+| `port` / `host_port` | container port / published port |
+| `health_path` | HTTP path polled after start (`""` = only check it stays running) |
+| `start` | start command for generated Dockerfiles |
+| `dockerfile` | custom Dockerfile path inside the repo |
+| `pre_deploy` | command run once in the new image before release (e.g. `python manage.py migrate`); failure aborts and the live version stays |
+| `env_file` | host env file passed to the container |
+| `token_env` | env var holding a git token (private https repos) |
+| `secret_env` | env var with this app's webhook secret |
+| `notify_env` | env var holding a Slack/Discord/Mattermost webhook URL |
+| `keep_images` | old images to keep (default 5; current + previous always kept) |
+| `build_args` | table of Docker build args |
+
+## Zero-downtime with Caddy
+
+Set `domain` on an app and shipit switches to **blue/green** deploys behind [Caddy](https://caddyserver.com):
+
+```toml
+[server]
+caddy_admin = "http://127.0.0.1:2019"   # default
+
+[[app]]
+name = "myapp"
+domain = "app.example.com"   # DNS must point at this server
+host_port = 9000             # slots use 127.0.0.1:9000 (blue) and :9001 (green)
+```
+
+A release starts the idle slot, waits for its health check, flips the Caddy route, waits
+`drain_seconds`, then removes the old slot - no gap, and HTTPS certificates come from Caddy automatically.
+If the health check or the Caddy update fails, the live version is untouched.
+
+Requirements: Caddy running with its admin API enabled (the default). **shipit owns the Caddy config** -
+it pushes a full config on every release and on `shipit serve` start, so don't hand-edit that Caddy instance.
+Apps without `domain` keep the simple mode (brief swap gap).
+
+## Run it as a service (systemd)
+
+```ini
+[Service]
+Environment=SHIPIT_SECRET=change-me
+WorkingDirectory=/opt/shipit
+ExecStart=/usr/local/bin/shipit serve
+Restart=always
+```
+
+Put nginx/Caddy in front for HTTPS and for routing domains to each app's `host_port`.
+
+## Security notes
+
+- The webhook endpoint rejects anything without a valid signature/token.
+- Deploying runs `docker build` on code from your repo – only point it at repos you trust.
+- Run `shipit serve` behind HTTPS; the host running it controls Docker, so keep it locked down.
+
+## Limitations (v0.1)
+
+Single server, single container per app. Without `domain` there is a brief gap while the port is handed over.
+PRs welcome – ideas: multi-server, PR preview deploys, web UI, Traefik/nginx backends.
+
+## Develop
+
+```bash
+python -m unittest discover -s tests
+```
+
+End-to-end tests deploy real sample apps with Docker (needs Docker + git, takes a few minutes):
+
+```bash
+SHIPIT_E2E=1 python -m unittest tests.test_e2e -v
+```
+
+Contributions welcome - see [CONTRIBUTING.md](CONTRIBUTING.md). Security issues: [SECURITY.md](SECURITY.md). MIT licensed.

shipit_deploy-0.2.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "shipit-deploy"
+version = "0.2.0"
+description = "Self-hosted, language-agnostic auto deploy: git push -> build -> health check -> rollback"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.11"
+dependencies = []
+keywords = ["deploy", "auto-deploy", "docker", "ci-cd", "self-hosted", "webhook", "devops"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Intended Audience :: System Administrators",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Build Tools",
+    "Topic :: System :: Software Distribution",
+]
+
+[project.urls]
+Homepage = "https://github.com/desnarong/shipit"
+Issues = "https://github.com/desnarong/shipit/issues"
+Changelog = "https://github.com/desnarong/shipit/blob/main/CHANGELOG.md"
+
+[project.scripts]
+shipit = "shipit.cli:main"
+
+[tool.setuptools]
+packages = ["shipit"]

shipit_deploy-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

shipit_deploy-0.2.0/shipit/__init__.py

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

shipit_deploy-0.2.0/shipit/__main__.py

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

shipit_deploy-0.2.0/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_deploy-0.2.0/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