djangocloud-cli 0.1.1__tar.gz

djangocloud_cli-0.1.1/.github/workflows/publish.yml

@@ -0,0 +1,31 @@
+# Publishes to PyPI when a GitHub Release is published. Uses PyPI "trusted publishing" (OIDC), so no
+# API token is stored anywhere. One-time setup: on pypi.org add a trusted publisher for this repository,
+# workflow "publish.yml", environment "pypi".
+name: publish
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      contents: read  # a job-level permissions block drops the defaults; checkout of a private repo needs this
+      id-token: write  # trusted publishing
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0  # the version is read from git tags
+      - uses: astral-sh/setup-uv@v5
+      - run: uv build
+      - name: Built version must match the release tag
+        run: |
+          set -euo pipefail
+          expected="${GITHUB_REF_NAME#v}"
+          built=$(ls dist/*.whl | sed -E 's#.*/[^-]+-([^-]+)-.*#\1#')
+          if [ "$built" != "$expected" ]; then
+            echo "::error::Built version $built does not match tag ${GITHUB_REF_NAME}"
+            exit 1
+          fi
+      - uses: pypa/gh-action-pypi-publish@release/v1

djangocloud_cli-0.1.1/.github/workflows/test.yml

@@ -0,0 +1,15 @@
+name: test
+on: [push, pull_request]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python: ["3.10", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - run: uv python install ${{ matrix.python }}
+      - run: uv sync --python ${{ matrix.python }}
+      - run: uv run ruff check
+      - run: uv run pytest

djangocloud_cli-0.1.1/.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.pyc
+.venv/
+dist/
+build/
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+.env
+*.pem
+src/djangocloud_cli/_version.py

djangocloud_cli-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Peter van Doorn
+
+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.

djangocloud_cli-0.1.1/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.5
+Name: djangocloud-cli
+Version: 0.1.1
+Summary: Deploy a Django app from the command line: djangocloud login, djangocloud deploy, djangocloud logs.
+Project-URL: Homepage, https://djangocloud.dev
+Project-URL: Source, https://github.com/two-trick-pony-NL/djangocloud-cli
+Project-URL: Issues, https://github.com/two-trick-pony-NL/djangocloud-cli/issues
+Author-email: Peter van Doorn <peter@petervandoorn.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: aws,cli,deploy,django,lightsail
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Framework :: Django :: 5.1
+Classifier: Framework :: Django :: 5.2
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Software Development
+Requires-Python: >=3.10
+Requires-Dist: questionary>=2.0
+Requires-Dist: rich>=13
+Description-Content-Type: text/markdown
+
+# djangocloud-cli
+
+Command-line client for DjangoCloud. Standard library only.
+
+```
+pip install djangocloud-cli          # then add "djangocloud_cli" to INSTALLED_APPS
+python manage.py djangocloud login
+python manage.py djangocloud deploy
+python manage.py djangocloud logs -f
+python manage.py djangocloud help
+```
+
+A standalone `djangocloud` script is installed too (same commands, no `manage.py`), for when your settings won't load.
+
+**Status:** early. `help`, `login`, `logout`, `whoami`, `link`, `unlink` and the interactive setup in `deploy` work
+(they need the DjangoCloud API). Uploading, building and deploying, `logs` and `status` are next.
+
+## First run
+
+```
+$ python manage.py djangocloud deploy
+You're not signed in yet.
+Open https://djangocloud.dev/dashboard/cli/?code=ABCD-EFGH and check that the code is ABCD-EFGH.
+✓ Signed in as you@example.com
+? Which project is this?  (arrow keys)
+? Server size  Nano  0.25 vCPU, 0.5 GB RAM  $10/month
+? This will cost $10 per month. Continue? Yes
+✓ Linked to my-shop (.djangocloud/config.json)
+```
+
+`.djangocloud/config.json` says which project this folder deploys to. It holds no secrets and is git-ignored by a
+`.gitignore` inside the folder. Later runs skip every prompt.
+
+## CI (GitHub Actions)
+
+Create a token under **Command line → Token for CI** in the dashboard and store it as the repository secret
+`DJANGOCLOUD_TOKEN`. `--no-input` makes the CLI fail with a clear message instead of ever prompting or opening a browser.
+
+```yaml
+- run: pip install djangocloud-cli
+- run: python manage.py djangocloud deploy --no-input --project my-shop
+  env:
+    DJANGOCLOUD_TOKEN: ${{ secrets.DJANGOCLOUD_TOKEN }}
+```
+
+## Configuration
+
+| Variable | Purpose |
+|---|---|
+| `DJANGOCLOUD_TOKEN` | API token for CI; takes precedence over the stored login |
+| `DJANGOCLOUD_NO_INPUT` | Same as `--no-input` (set it to `1`) |
+| `DJANGOCLOUD_API` | API base URL (default `https://djangocloud.dev/api/v1`) |
+
+The token from `login` is stored in `~/.config/djangocloud/credentials.json` (mode 600).
+
+## Development
+
+```
+uv sync
+uv run pytest
+uv run ruff check
+```

djangocloud_cli-0.1.1/README.md

@@ -0,0 +1,62 @@
+# djangocloud-cli
+
+Command-line client for DjangoCloud. Standard library only.
+
+```
+pip install djangocloud-cli          # then add "djangocloud_cli" to INSTALLED_APPS
+python manage.py djangocloud login
+python manage.py djangocloud deploy
+python manage.py djangocloud logs -f
+python manage.py djangocloud help
+```
+
+A standalone `djangocloud` script is installed too (same commands, no `manage.py`), for when your settings won't load.
+
+**Status:** early. `help`, `login`, `logout`, `whoami`, `link`, `unlink` and the interactive setup in `deploy` work
+(they need the DjangoCloud API). Uploading, building and deploying, `logs` and `status` are next.
+
+## First run
+
+```
+$ python manage.py djangocloud deploy
+You're not signed in yet.
+Open https://djangocloud.dev/dashboard/cli/?code=ABCD-EFGH and check that the code is ABCD-EFGH.
+✓ Signed in as you@example.com
+? Which project is this?  (arrow keys)
+? Server size  Nano  0.25 vCPU, 0.5 GB RAM  $10/month
+? This will cost $10 per month. Continue? Yes
+✓ Linked to my-shop (.djangocloud/config.json)
+```
+
+`.djangocloud/config.json` says which project this folder deploys to. It holds no secrets and is git-ignored by a
+`.gitignore` inside the folder. Later runs skip every prompt.
+
+## CI (GitHub Actions)
+
+Create a token under **Command line → Token for CI** in the dashboard and store it as the repository secret
+`DJANGOCLOUD_TOKEN`. `--no-input` makes the CLI fail with a clear message instead of ever prompting or opening a browser.
+
+```yaml
+- run: pip install djangocloud-cli
+- run: python manage.py djangocloud deploy --no-input --project my-shop
+  env:
+    DJANGOCLOUD_TOKEN: ${{ secrets.DJANGOCLOUD_TOKEN }}
+```
+
+## Configuration
+
+| Variable | Purpose |
+|---|---|
+| `DJANGOCLOUD_TOKEN` | API token for CI; takes precedence over the stored login |
+| `DJANGOCLOUD_NO_INPUT` | Same as `--no-input` (set it to `1`) |
+| `DJANGOCLOUD_API` | API base URL (default `https://djangocloud.dev/api/v1`) |
+
+The token from `login` is stored in `~/.config/djangocloud/credentials.json` (mode 600).
+
+## Development
+
+```
+uv sync
+uv run pytest
+uv run ruff check
+```

djangocloud_cli-0.1.1/pyproject.toml

@@ -0,0 +1,62 @@
+[project]
+name = "djangocloud-cli"
+dynamic = ["version"]  # from the git tag (hatch-vcs): tag v0.2.0 -> version 0.2.0
+description = "Deploy a Django app from the command line: djangocloud login, djangocloud deploy, djangocloud logs."
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = ["rich>=13", "questionary>=2.0"]
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Peter van Doorn", email = "peter@petervandoorn.com" }]
+keywords = ["django", "deploy", "cli", "aws", "lightsail"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Framework :: Django",
+    "Framework :: Django :: 4.2",
+    "Framework :: Django :: 5.0",
+    "Framework :: Django :: 5.1",
+    "Framework :: Django :: 5.2",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development",
+]
+
+[project.urls]
+Homepage = "https://djangocloud.dev"
+Source = "https://github.com/two-trick-pony-NL/djangocloud-cli"
+Issues = "https://github.com/two-trick-pony-NL/djangocloud-cli/issues"
+
+[project.scripts]
+djangocloud = "djangocloud_cli.cli:main"
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.build.hooks.vcs]
+version-file = "src/djangocloud_cli/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/djangocloud_cli"]
+
+[dependency-groups]
+dev = ["pytest>=8", "ruff>=0.6", "django>=4.2"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 120
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP"]

djangocloud_cli-0.1.1/src/djangocloud_cli/__init__.py

@@ -0,0 +1,6 @@
+"""Command-line client for DjangoCloud."""
+
+try:
+    from ._version import __version__  # written at build time from the git tag
+except ImportError:  # running from a checkout that was never built
+    __version__ = "0.0.0+unknown"

djangocloud_cli-0.1.1/src/djangocloud_cli/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.1'
+__version_tuple__ = version_tuple = (0, 1, 1)
+
+__commit_id__ = commit_id = None

djangocloud_cli-0.1.1/src/djangocloud_cli/api.py

@@ -0,0 +1,48 @@
+"""Minimal JSON client for the DjangoCloud API (urllib: no HTTP dependency to conflict with)."""
+
+import json
+import urllib.error
+import urllib.request
+
+from . import __version__
+
+TIMEOUT = 30
+
+
+class ApiError(Exception):
+    def __init__(self, status: int, code: str, message: str):
+        super().__init__(message)
+        self.status, self.code, self.message = status, code, message
+
+
+class Client:
+    def __init__(self, base_url: str, token: str | None = None):
+        self.base_url = base_url.rstrip("/")
+        self.token = token
+
+    def request(self, method: str, path: str, data: dict | None = None) -> dict:
+        headers = {"Accept": "application/json", "User-Agent": f"djangocloud-cli/{__version__}"}
+        body = None
+        if data is not None:
+            body = json.dumps(data).encode()
+            headers["Content-Type"] = "application/json"
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+        req = urllib.request.Request(self.base_url + path, data=body, headers=headers, method=method)
+        try:
+            with urllib.request.urlopen(req, timeout=TIMEOUT) as response:
+                return json.loads(response.read() or b"{}")
+        except urllib.error.HTTPError as exc:
+            try:
+                payload = json.loads(exc.read())
+            except ValueError:
+                payload = {}
+            raise ApiError(exc.code, payload.get("error", "http_error"), payload.get("message", exc.reason)) from None
+        except (urllib.error.URLError, TimeoutError) as exc:
+            raise ApiError(0, "unreachable", f"Couldn't reach {self.base_url}: {getattr(exc, 'reason', exc)}") from None
+
+    def get(self, path: str) -> dict:
+        return self.request("GET", path)
+
+    def post(self, path: str, data: dict | None = None) -> dict:
+        return self.request("POST", path, data or {})

djangocloud_cli-0.1.1/src/djangocloud_cli/auth.py

@@ -0,0 +1,37 @@
+"""`djangocloud login`: the device-code flow. No passwords or keys are typed into the terminal."""
+
+import time
+import webbrowser
+
+from . import config
+from .api import ApiError, Client
+from .ui import console
+
+
+def login(client: Client, *, sleep=time.sleep, open_browser=webbrowser.open, client_name: str = "cloud CLI") -> str:
+    started = client.post("/auth/device", {"client_name": client_name})
+    url, code = started["verification_uri_complete"], started["user_code"]
+    console.print(f"\nOpen [link={url}]{url}[/link]\nand check that the code is [bold]{code}[/bold].\n")
+    try:
+        open_browser(url)
+    except Exception:  # noqa: BLE001 - no browser (SSH, CI) is fine: the URL is printed above
+        pass
+
+    interval = started.get("interval", 5)
+    deadline = time.monotonic() + started.get("expires_in", 600)
+    with console.status("Waiting for you to approve in the browser…"):
+        while time.monotonic() < deadline:
+            sleep(interval)
+            try:
+                token = client.post("/auth/token", {"device_code": started["device_code"]})["access_token"]
+            except ApiError as exc:
+                if exc.code == "authorization_pending":
+                    continue
+                if exc.code == "slow_down":
+                    interval += 5
+                    continue
+                raise
+            config.save_token(token)
+            client.token = token
+            return token
+    raise ApiError(400, "expired_token", "That login expired. Run the login command again.")

djangocloud_cli-0.1.1/src/djangocloud_cli/cli.py

@@ -0,0 +1,233 @@
+"""`djangocloud` command: one parser shared by the standalone script and `manage.py djangocloud`."""
+
+import argparse
+import sys
+
+from . import __version__, auth, config, link
+from .api import ApiError, Client
+from .ui import NotInteractive, confirm, console, err, interactive, no_input, select, set_no_input, text
+
+STANDALONE = "djangocloud"
+MANAGE_PY = "python manage.py djangocloud"
+_prog = MANAGE_PY  # what messages tell people to type; set by run() to match how we were invoked
+
+
+def say(command: str) -> str:
+    """The command as the user types it, e.g. 'python manage.py djangocloud login'."""
+    return f"{_prog} {command}"
+
+
+COMING_SOON = "'{command}' isn't available yet: the build and deploy pipeline is still being built."
+
+
+def build_parser(prog: str = STANDALONE) -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog=prog, description="Deploy your Django app.")
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    parser.add_argument(
+        "--no-input",
+        action="store_true",
+        help="Never prompt or open a browser (for CI). Needs DJANGOCLOUD_TOKEN and a linked folder or --project",
+    )
+    sub = parser.add_subparsers(dest="command", metavar="<command>")
+
+    sub.add_parser("login", help="Sign in (approve a code in your browser)")
+    sub.add_parser("logout", help="Forget the stored token")
+    sub.add_parser("whoami", help="Show who you are signed in as")
+
+    linkers = (
+        ("deploy", "Link this folder to a project, then deploy it"),
+        ("link", "Pick or create the project this folder deploys to"),
+    )
+    for name, helptext in linkers:
+        cmd = sub.add_parser(name, help=helptext)
+        cmd.add_argument("--project", help="Use this existing project (slug) without prompting")
+        cmd.add_argument("--name", help="Create a new project with this name without prompting")
+        cmd.add_argument("--size", help="Server size for a new project, e.g. nano")
+        cmd.add_argument("-y", "--yes", action="store_true", help="Don't ask for confirmation")
+    sub.add_parser("unlink", help="Detach this folder from its project")
+    sub.add_parser("status", help="Show the current release and its state")
+
+    logs = sub.add_parser("logs", help="Show a project's logs")
+    logs.add_argument("-f", "--follow", action="store_true", help="Keep streaming new lines")
+    logs.add_argument("--source", choices=["app", "build", "release"], help="Only this kind of log line")
+    logs.add_argument("--since", metavar="DURATION", help="Only lines newer than this, e.g. 2h")
+
+    helper = sub.add_parser("help", help="Show this help")
+    helper.add_argument("topic", nargs="?", help="A command to get help for")
+    return parser
+
+
+class CliError(Exception):
+    pass
+
+
+def make_client() -> Client:
+    return Client(config.api_url(), config.load_token())
+
+
+def ensure_login(client: Client) -> None:
+    """Make sure the client holds a token the server accepts, signing in if it doesn't."""
+    if client.token:
+        try:
+            client.get("/me")
+            return
+        except ApiError as exc:
+            if exc.code != "unauthorized":
+                raise
+    if not interactive():
+        raise CliError(
+            "Not signed in. In CI set DJANGOCLOUD_TOKEN (create one at /dashboard/cli/); "
+            f"on your own machine run '{say('login')}'."
+        )
+    console.print("You're not signed in yet.")
+    auth.login(client)
+    console.print(f"[green]✓[/green] Signed in as {client.get('/me')['email']}")
+
+
+def _price(cents: int) -> str:
+    return f"${cents / 100:,.0f}" if cents % 100 == 0 else f"${cents / 100:,.2f}"
+
+
+def _size_label(size: dict) -> str:
+    specs = f"{size['vcpu']:g} vCPU, {size['ram_gb']:g} GB RAM"
+    return f"{size['label']:<8} {specs:<22} {_price(size['price_cents'])}/month"
+
+
+def ensure_linked(client: Client, root, args, *, force: bool = False) -> dict:
+    existing = None if force else link.load(root)
+    if existing:
+        return existing
+
+    projects = client.get("/projects")["projects"]
+    if args.project:
+        match = next((p for p in projects if p["slug"] == args.project), None)
+        if match is None:
+            raise CliError(f"No project {args.project!r} on your account.")
+        project = match
+    else:
+        choice = args.name or select(
+            "Which project is this?",
+            [("Create a new project", None)] + [(f"{p['name'] or p['slug']}  ({p['slug']})", p) for p in projects],
+        )
+        project = choice if isinstance(choice, dict) else create_project(client, root, args)
+    path = link.save(root, project, config.api_url())
+    console.print(f"[green]✓[/green] Linked to [bold]{project['slug']}[/bold] ({path.relative_to(root)})")
+    return project
+
+
+def create_project(client: Client, root, args) -> dict:
+    name = args.name or text("Project name", default=root.name)
+    sizes = client.get("/sizes")["sizes"]
+    if args.size:
+        size = next((s for s in sizes if s["power"] == args.size), None)
+        if size is None:
+            raise CliError(f"Unknown size {args.size!r}. Choose from: {', '.join(s['power'] for s in sizes)}.")
+    else:
+        size = select("Server size", [(_size_label(s), s) for s in sizes])
+    monthly = _price(size["price_cents"])
+    if not (args.yes or no_input()) and not confirm(f"This will cost {monthly} per month. Continue?"):
+        raise CliError("Cancelled. Nothing was created.")
+    try:
+        return client.post("/projects", {"name": name, "power": size["power"]})
+    except ApiError as exc:
+        if exc.code == "payment_required":
+            raise CliError(f"{exc.message}") from None
+        raise
+
+
+def cmd_login(args, root) -> int:
+    if not interactive():
+        raise CliError(f"'{say('login')}' needs a browser. In CI use a DJANGOCLOUD_TOKEN instead.")
+    client = make_client()
+    auth.login(client)
+    console.print(f"[green]✓[/green] Signed in as {client.get('/me')['email']}")
+    return 0
+
+
+def cmd_whoami(args, root) -> int:
+    client = make_client()
+    if not client.token:
+        console.print(f"Not signed in. Run [bold]{say('login')}[/bold].")
+        return 1
+    try:
+        me = client.get("/me")
+    except ApiError as exc:
+        if exc.code != "unauthorized":
+            raise
+        console.print(f"Your token is no longer valid. Run [bold]{say('login')}[/bold].")
+        return 1
+    console.print(f"Signed in as [bold]{me['email']}[/bold]")
+    linked = link.load(root)
+    if linked:
+        console.print(f"This folder deploys to [bold]{linked['slug']}[/bold].")
+    return 0
+
+
+def cmd_logout(args, root) -> int:
+    console.print("Signed out." if config.clear_token() else "You weren't signed in.")
+    return 0
+
+
+def cmd_link(args, root) -> int:
+    client = make_client()
+    ensure_login(client)
+    ensure_linked(client, root, args, force=True)
+    return 0
+
+
+def cmd_unlink(args, root) -> int:
+    console.print("Unlinked." if link.remove(root) else "This folder isn't linked.")
+    return 0
+
+
+def cmd_deploy(args, root) -> int:
+    client = make_client()
+    ensure_login(client)
+    project = ensure_linked(client, root, args)
+    console.print(f"Ready to deploy [bold]{project['slug']}[/bold].")
+    err.print(COMING_SOON.format(command=say("deploy")))
+    err.print("Your project is linked, so the next release will pick it up.")
+    return 2
+
+
+COMMANDS = {
+    "login": cmd_login,
+    "logout": cmd_logout,
+    "whoami": cmd_whoami,
+    "link": cmd_link,
+    "unlink": cmd_unlink,
+    "deploy": cmd_deploy,
+}
+
+
+def run(argv: list[str] | None = None, prog: str = STANDALONE) -> int:
+    global _prog
+    _prog = prog
+    parser = build_parser(prog)
+    args = parser.parse_args(argv)
+    set_no_input(getattr(args, "no_input", False))
+
+    if args.command in (None, "help"):
+        topic = getattr(args, "topic", None)
+        if topic:
+            return run([topic, "--help"], prog)  # argparse prints the sub-command's help, then exits
+        parser.print_help()
+        return 0
+    handler = COMMANDS.get(args.command)
+    if handler is None:
+        err.print(COMING_SOON.format(command=say(args.command)))
+        return 2
+    try:
+        return handler(args, link.find_root())
+    except (CliError, NotInteractive) as exc:
+        err.print(f"[red]Error:[/red] {exc}")
+    except ApiError as exc:
+        err.print(f"[red]Error:[/red] {exc.message}")
+    except KeyboardInterrupt:
+        err.print("\nCancelled.")
+        return 130
+    return 1
+
+
+def main() -> None:
+    sys.exit(run(sys.argv[1:]))