saq-board 0.1.0__tar.gz

saq_board-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+.venv/
+__pycache__/
+*.pyc
+.pytest_cache/
+.ruff_cache/
+dist/
+build/
+*.egg-info/
+dump.rdb

saq_board-0.1.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 rkwap (https://github.com/rkwap)
+Copyright (c) 2021 Toby Mao, for the parts adapted from SAQ's dashboard (https://github.com/tobymao/saq)
+
+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.

saq_board-0.1.0/PKG-INFO

@@ -0,0 +1,186 @@
+Metadata-Version: 2.5
+Name: saq-board
+Version: 0.1.0
+Summary: A bull-board style dashboard for SAQ, with Sidekiq-cron style cron jobs
+Project-URL: Homepage, https://github.com/rkwap/saq-board
+Author: rkwap
+License-Expression: MIT
+License-File: LICENSE
+License-File: THIRD_PARTY_NOTICES.md
+License-File: saq_board/web/static/fonts/OFL.txt
+Keywords: cron,dashboard,queue,redis,saq
+Classifier: Framework :: AsyncIO
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.9
+Requires-Dist: croniter>=1.0
+Requires-Dist: saq[redis]>=0.24.13
+Provides-Extra: dev
+Requires-Dist: aiohttp; extra == 'dev'
+Requires-Dist: aiohttp-basicauth; extra == 'dev'
+Requires-Dist: httpx; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-aiohttp; extra == 'dev'
+Requires-Dist: pytest-asyncio; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: starlette; extra == 'dev'
+Provides-Extra: starlette
+Requires-Dist: starlette; extra == 'starlette'
+Provides-Extra: web
+Requires-Dist: aiohttp; extra == 'web'
+Requires-Dist: aiohttp-basicauth; extra == 'web'
+Description-Content-Type: text/markdown
+
+# SAQ Board
+
+A dashboard for [SAQ](https://github.com/tobymao/saq) inspired by [bull-board](https://github.com/felixmosh/bull-board).
+
+It extends SAQ's built-in dashboard and its API is a superset of SAQ's, so it drops in wherever you use `saq.web` today.
+
+![Overview](docs/overview.png)
+
+| Queue | Cron jobs |
+| --- | --- |
+| ![Failed jobs](docs/queue.png) | ![Cron jobs](docs/cron.png) |
+
+## Features
+
+- **Queues**: overview with live counts, per-queue tabs for active, queued, scheduled, completed, failed and aborted jobs, plus workers.
+- **Jobs**: bull-board style cards with a timeline, data, result, error and options tabs, progress bars, and retry, abort, run now (promote), duplicate and remove actions.
+- **Bulk actions**: retry all, clean all, promote all, abort all.
+- **Pause and resume** a queue.
+- **Add jobs** from the dashboard, picking from the functions your workers register.
+- **Cron jobs**, Sidekiq-cron style: defined in code, then enabled, disabled, enqueued now or deleted from the dashboard, with next run, last enqueued and history.
+- Light and dark theme, adjustable refresh, relative or absolute times, local or UTC, read-only mode, Redis stats.
+- Preact + htm with no build step, like SAQ's own dashboard. Fonts and scripts ship with the package, so it works offline.
+
+## Install
+
+```sh
+pip install "saq-board[starlette]"   # Starlette / FastAPI
+pip install "saq-board[web]"         # aiohttp and the saq-board command
+```
+
+Redis queues only for now.
+
+## 1. Add the plugin to your workers
+
+SAQ doesn't keep finished jobs, can't pause a queue and schedules cron jobs in code only. The plugin adds all three. Wrap your worker settings:
+
+```python
+from saq import Queue
+from saq_board import CronJob, with_board
+
+queue = Queue.from_url("redis://localhost")
+
+settings = with_board({
+    "queue": queue,
+    "functions": [send_email],
+    "cron_jobs": [
+        CronJob(cleanup, cron="0 * * * *", description="Hourly cleanup"),
+    ],
+})
+```
+
+Run workers exactly as before: `saq app.worker.settings`.
+
+`with_board(settings, history_limit=1000, cron_poll=1.0)`:
+
+- `history_limit`: finished jobs kept per status (complete, failed, aborted). The oldest are dropped first.
+- `cron_poll`: seconds between cron checks.
+
+## 2. Run the dashboard
+
+**Starlette / FastAPI**, a drop-in for `saq.web.starlette.saq_web`:
+
+```python
+from starlette.routing import Mount
+from saq_board import saq_board
+
+routes = [Mount("/monitor", saq_board("/monitor", queues=[queue]))]
+# FastAPI: app.mount("/monitor", saq_board("/monitor", queues=[queue]))
+```
+
+**aiohttp**, a drop-in for `saq.web.aiohttp.create_app`:
+
+```python
+from saq_board import create_app
+
+app.add_subapp("/monitor", create_app([queue], root_path="/monitor"))
+```
+
+**On its own**:
+
+```sh
+saq-board --url redis://localhost:6379                # queues registered by the plugin
+saq-board --url redis://localhost:6379 -q default -q emails
+saq-board --settings app.worker.settings --port 8080
+```
+
+All of them take `read_only=True` (`--read-only`), which hides every action and rejects them server-side.
+
+### Authentication
+
+Same as SAQ's dashboard. The aiohttp app and the `saq-board` command turn on basic auth when `AUTH_PASSWORD` is set (user `AUTH_USER`, default `admin`); this needs `aiohttp_basicauth`, which the `web` extra installs. With Starlette or FastAPI, protect the mount with your own middleware or dependencies.
+
+## Cron jobs
+
+Cron jobs work like Sidekiq-cron:
+
+- They are defined in code (`cron_jobs` in the worker settings) and synced to Redis when a worker starts.
+- The dashboard enables, disables, enqueues now or deletes them. Enabled or disabled survives restarts; a deleted job comes back the next time a worker that defines it starts.
+- Every worker process checks the schedule, and a claim in Redis makes sure each run is enqueued once.
+- A run that is more than 60 seconds late (for example, no worker was up) is skipped, not caught up.
+- `unique=True` (the default, as in SAQ) skips a run while the previous one is still queued or running.
+- Times follow the worker's `cron_tz` (UTC by default).
+
+`saq_board.CronJob` is SAQ's `CronJob` plus `name`, `description` and `enabled` (the initial state). Plain `saq.CronJob` works too and is named after its function. Give jobs that share a function different names.
+
+## API
+
+Everything SAQ's dashboard serves, plus:
+
+| Method | Path | |
+| --- | --- | --- |
+| GET | `/api/queues` | Queues with counts, totals, paused flag and workers |
+| GET | `/api/queues/{queue}` | One queue, as in SAQ, plus the registered functions |
+| GET | `/api/queues/{queue}/jobs?status=&offset=&limit=` | Jobs by status |
+| POST | `/api/queues/{queue}/jobs` | Add a job: `{"function", "kwargs", "options"}` |
+| GET | `/api/queues/{queue}/jobs/{job}` | One job |
+| POST | `/api/queues/{queue}/jobs/{job}/{action}` | `retry`, `abort`, `promote`, `remove` |
+| POST | `/api/queues/{queue}/{action}` | `pause`, `resume`, `promote-all`, and with `{"status"}`: `clean`, `retry-all`, `abort-all` |
+| GET | `/api/redis` | Redis stats |
+| GET | `/api/cron` | Cron jobs |
+| GET | `/api/cron/{queue}/{name}` | One cron job with its history |
+| POST | `/api/cron/{queue}/{name}/{action}` | `enqueue`, `enable`, `disable`, `delete` |
+| POST | `/api/cron/{action}-all` | The same for every cron job |
+
+## How it works
+
+The plugin wraps the worker's queue: `finish` also records the job in a capped history, and `dequeue` waits while the queue is paused (a pause takes effect within a second). It also moves `cron_jobs` to its own scheduler, so SAQ's scheduler doesn't run them too, and tags the worker's metadata so the dashboard can tell whether workers run the plugin.
+
+Board data lives under each queue's SAQ namespace, `saq:<queue>:board:*`, so it goes away with the queue.
+
+## Development
+
+```sh
+python -m venv .venv && .venv/bin/pip install -e ".[dev]" uvicorn
+redis-server --daemonize yes
+.venv/bin/pytest            # uses redis://localhost:6379/15, override with SAQ_BOARD_TEST_REDIS
+.venv/bin/python examples/demo.py   # http://localhost:8000/monitor
+```
+
+## Credits
+
+Built by [rkwap](https://github.com/rkwap).
+
+SAQ Board stands on the shoulders of:
+
+- [SAQ](https://github.com/tobymao/saq) by [Toby Mao](https://github.com/tobymao) (MIT): the queue this extends, whose dashboard API, structure and `#1095c1` accent it keeps.
+- [bull-board](https://github.com/felixmosh/bull-board) by [felixmosh](https://github.com/felixmosh) (MIT): the dashboard design it follows.
+- [Sidekiq-cron](https://github.com/sidekiq-cron/sidekiq-cron) by [ondrejbartas](https://github.com/ondrejbartas) and contributors (MIT): how cron jobs behave and look.
+- [Preact](https://preactjs.com) (MIT) and [htm](https://github.com/developit/htm) (Apache-2.0) by Jason Miller, [Feather icons](https://feathericons.com) by Cole Bemis (MIT), and the [Geist](https://vercel.com/font) fonts (SIL OFL 1.1), all bundled. See [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md).
+
+## License
+
+[MIT](LICENSE), like SAQ and bull-board.

saq_board-0.1.0/README.md

@@ -0,0 +1,153 @@
+# SAQ Board
+
+A dashboard for [SAQ](https://github.com/tobymao/saq) inspired by [bull-board](https://github.com/felixmosh/bull-board).
+
+It extends SAQ's built-in dashboard and its API is a superset of SAQ's, so it drops in wherever you use `saq.web` today.
+
+![Overview](docs/overview.png)
+
+| Queue | Cron jobs |
+| --- | --- |
+| ![Failed jobs](docs/queue.png) | ![Cron jobs](docs/cron.png) |
+
+## Features
+
+- **Queues**: overview with live counts, per-queue tabs for active, queued, scheduled, completed, failed and aborted jobs, plus workers.
+- **Jobs**: bull-board style cards with a timeline, data, result, error and options tabs, progress bars, and retry, abort, run now (promote), duplicate and remove actions.
+- **Bulk actions**: retry all, clean all, promote all, abort all.
+- **Pause and resume** a queue.
+- **Add jobs** from the dashboard, picking from the functions your workers register.
+- **Cron jobs**, Sidekiq-cron style: defined in code, then enabled, disabled, enqueued now or deleted from the dashboard, with next run, last enqueued and history.
+- Light and dark theme, adjustable refresh, relative or absolute times, local or UTC, read-only mode, Redis stats.
+- Preact + htm with no build step, like SAQ's own dashboard. Fonts and scripts ship with the package, so it works offline.
+
+## Install
+
+```sh
+pip install "saq-board[starlette]"   # Starlette / FastAPI
+pip install "saq-board[web]"         # aiohttp and the saq-board command
+```
+
+Redis queues only for now.
+
+## 1. Add the plugin to your workers
+
+SAQ doesn't keep finished jobs, can't pause a queue and schedules cron jobs in code only. The plugin adds all three. Wrap your worker settings:
+
+```python
+from saq import Queue
+from saq_board import CronJob, with_board
+
+queue = Queue.from_url("redis://localhost")
+
+settings = with_board({
+    "queue": queue,
+    "functions": [send_email],
+    "cron_jobs": [
+        CronJob(cleanup, cron="0 * * * *", description="Hourly cleanup"),
+    ],
+})
+```
+
+Run workers exactly as before: `saq app.worker.settings`.
+
+`with_board(settings, history_limit=1000, cron_poll=1.0)`:
+
+- `history_limit`: finished jobs kept per status (complete, failed, aborted). The oldest are dropped first.
+- `cron_poll`: seconds between cron checks.
+
+## 2. Run the dashboard
+
+**Starlette / FastAPI**, a drop-in for `saq.web.starlette.saq_web`:
+
+```python
+from starlette.routing import Mount
+from saq_board import saq_board
+
+routes = [Mount("/monitor", saq_board("/monitor", queues=[queue]))]
+# FastAPI: app.mount("/monitor", saq_board("/monitor", queues=[queue]))
+```
+
+**aiohttp**, a drop-in for `saq.web.aiohttp.create_app`:
+
+```python
+from saq_board import create_app
+
+app.add_subapp("/monitor", create_app([queue], root_path="/monitor"))
+```
+
+**On its own**:
+
+```sh
+saq-board --url redis://localhost:6379                # queues registered by the plugin
+saq-board --url redis://localhost:6379 -q default -q emails
+saq-board --settings app.worker.settings --port 8080
+```
+
+All of them take `read_only=True` (`--read-only`), which hides every action and rejects them server-side.
+
+### Authentication
+
+Same as SAQ's dashboard. The aiohttp app and the `saq-board` command turn on basic auth when `AUTH_PASSWORD` is set (user `AUTH_USER`, default `admin`); this needs `aiohttp_basicauth`, which the `web` extra installs. With Starlette or FastAPI, protect the mount with your own middleware or dependencies.
+
+## Cron jobs
+
+Cron jobs work like Sidekiq-cron:
+
+- They are defined in code (`cron_jobs` in the worker settings) and synced to Redis when a worker starts.
+- The dashboard enables, disables, enqueues now or deletes them. Enabled or disabled survives restarts; a deleted job comes back the next time a worker that defines it starts.
+- Every worker process checks the schedule, and a claim in Redis makes sure each run is enqueued once.
+- A run that is more than 60 seconds late (for example, no worker was up) is skipped, not caught up.
+- `unique=True` (the default, as in SAQ) skips a run while the previous one is still queued or running.
+- Times follow the worker's `cron_tz` (UTC by default).
+
+`saq_board.CronJob` is SAQ's `CronJob` plus `name`, `description` and `enabled` (the initial state). Plain `saq.CronJob` works too and is named after its function. Give jobs that share a function different names.
+
+## API
+
+Everything SAQ's dashboard serves, plus:
+
+| Method | Path | |
+| --- | --- | --- |
+| GET | `/api/queues` | Queues with counts, totals, paused flag and workers |
+| GET | `/api/queues/{queue}` | One queue, as in SAQ, plus the registered functions |
+| GET | `/api/queues/{queue}/jobs?status=&offset=&limit=` | Jobs by status |
+| POST | `/api/queues/{queue}/jobs` | Add a job: `{"function", "kwargs", "options"}` |
+| GET | `/api/queues/{queue}/jobs/{job}` | One job |
+| POST | `/api/queues/{queue}/jobs/{job}/{action}` | `retry`, `abort`, `promote`, `remove` |
+| POST | `/api/queues/{queue}/{action}` | `pause`, `resume`, `promote-all`, and with `{"status"}`: `clean`, `retry-all`, `abort-all` |
+| GET | `/api/redis` | Redis stats |
+| GET | `/api/cron` | Cron jobs |
+| GET | `/api/cron/{queue}/{name}` | One cron job with its history |
+| POST | `/api/cron/{queue}/{name}/{action}` | `enqueue`, `enable`, `disable`, `delete` |
+| POST | `/api/cron/{action}-all` | The same for every cron job |
+
+## How it works
+
+The plugin wraps the worker's queue: `finish` also records the job in a capped history, and `dequeue` waits while the queue is paused (a pause takes effect within a second). It also moves `cron_jobs` to its own scheduler, so SAQ's scheduler doesn't run them too, and tags the worker's metadata so the dashboard can tell whether workers run the plugin.
+
+Board data lives under each queue's SAQ namespace, `saq:<queue>:board:*`, so it goes away with the queue.
+
+## Development
+
+```sh
+python -m venv .venv && .venv/bin/pip install -e ".[dev]" uvicorn
+redis-server --daemonize yes
+.venv/bin/pytest            # uses redis://localhost:6379/15, override with SAQ_BOARD_TEST_REDIS
+.venv/bin/python examples/demo.py   # http://localhost:8000/monitor
+```
+
+## Credits
+
+Built by [rkwap](https://github.com/rkwap).
+
+SAQ Board stands on the shoulders of:
+
+- [SAQ](https://github.com/tobymao/saq) by [Toby Mao](https://github.com/tobymao) (MIT): the queue this extends, whose dashboard API, structure and `#1095c1` accent it keeps.
+- [bull-board](https://github.com/felixmosh/bull-board) by [felixmosh](https://github.com/felixmosh) (MIT): the dashboard design it follows.
+- [Sidekiq-cron](https://github.com/sidekiq-cron/sidekiq-cron) by [ondrejbartas](https://github.com/ondrejbartas) and contributors (MIT): how cron jobs behave and look.
+- [Preact](https://preactjs.com) (MIT) and [htm](https://github.com/developit/htm) (Apache-2.0) by Jason Miller, [Feather icons](https://feathericons.com) by Cole Bemis (MIT), and the [Geist](https://vercel.com/font) fonts (SIL OFL 1.1), all bundled. See [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md).
+
+## License
+
+[MIT](LICENSE), like SAQ and bull-board.

saq_board-0.1.0/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,44 @@
+# Third-party notices
+
+SAQ Board ships these third-party files in `saq_board/web/static/`.
+
+## Preact 10 (in `vendor/preact-htm.js`)
+
+MIT License. Copyright (c) 2015-present Jason Miller. https://github.com/preactjs/preact
+
+## htm 3.1.1 (in `vendor/preact-htm.js`)
+
+Apache License, Version 2.0. Copyright 2018 Google Inc. https://github.com/developit/htm
+
+You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.
+The file is the unmodified `htm/preact/standalone.module.js` build, with a header comment added.
+
+## Feather icons (paths inlined in `app.js`)
+
+MIT License. Copyright (c) 2013-2023 Cole Bemis. https://github.com/feathericons/feather
+
+## Geist and Geist Mono (in `fonts/`)
+
+SIL Open Font License, Version 1.1. Copyright 2024 The Geist Project Authors. https://github.com/vercel/geist-font
+
+The full license is in `saq_board/web/static/fonts/OFL.txt`.
+
+## MIT License text
+
+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.

saq_board-0.1.0/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "saq-board"
+dynamic = ["version"]
+description = "A bull-board style dashboard for SAQ, with Sidekiq-cron style cron jobs"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE", "THIRD_PARTY_NOTICES.md", "saq_board/web/static/fonts/OFL.txt"]
+authors = [{ name = "rkwap" }]
+requires-python = ">=3.9"
+dependencies = ["saq[redis]>=0.24.13", "croniter>=1.0"]
+keywords = ["saq", "queue", "dashboard", "cron", "redis"]
+classifiers = [
+    "Framework :: AsyncIO",
+    "Programming Language :: Python :: 3",
+    "Topic :: System :: Monitoring",
+]
+
+[project.optional-dependencies]
+starlette = ["starlette"]
+web = ["aiohttp", "aiohttp_basicauth"]
+dev = ["saq-board[starlette,web]", "httpx", "pytest", "pytest-asyncio", "pytest-aiohttp", "ruff"]
+
+[project.scripts]
+saq-board = "saq_board.__main__:main"
+
+[project.urls]
+Homepage = "https://github.com/rkwap/saq-board"
+
+[tool.hatch.version]
+path = "saq_board/__init__.py"
+
+[tool.hatch.build.targets.sdist]
+include = ["saq_board", "README.md", "LICENSE", "THIRD_PARTY_NOTICES.md"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+
+[tool.ruff]
+line-length = 110
+target-version = "py39"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+ignore = ["UP007", "UP045"]

saq_board-0.1.0/saq_board/__init__.py

@@ -0,0 +1,33 @@
+"""
+SAQ Board: a bull-board style dashboard for SAQ with Sidekiq-cron style cron jobs.
+"""
+
+from __future__ import annotations
+
+import typing as t
+
+__version__ = "0.1.0"
+
+from saq_board.cron import CronJob  # noqa: E402
+from saq_board.worker import track, with_board  # noqa: E402
+
+if t.TYPE_CHECKING:
+    from aiohttp.web import Application
+    from saq.queue import Queue
+    from starlette.applications import Starlette
+
+__all__ = ["CronJob", "__version__", "create_app", "saq_board", "track", "with_board"]
+
+
+def saq_board(root_path: str, queues: list[Queue], **kwargs: t.Any) -> Starlette:
+    """Starlette/FastAPI app, a drop-in for ``saq.web.starlette.saq_web``."""
+    from saq_board.web.starlette import saq_board as app
+
+    return app(root_path, queues, **kwargs)
+
+
+def create_app(queues: list[Queue], **kwargs: t.Any) -> Application:
+    """aiohttp app, a drop-in for ``saq.web.aiohttp.create_app``."""
+    from saq_board.web.aiohttp import create_app as app
+
+    return app(queues, **kwargs)

saq_board-0.1.0/saq_board/__main__.py

@@ -0,0 +1,84 @@
+"""
+saq-board: run the dashboard on its own.
+
+    saq-board --url redis://localhost:6379 --queue default --queue emails
+    saq-board --settings app.worker.settings
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import logging
+import os
+import sys
+
+from saq.queue import Queue
+
+from saq_board.store import REGISTRY, text
+
+
+def discover(url: str) -> list[str]:
+    """Queue names registered by the worker plugin, else found by scanning for SAQ keys."""
+    from redis import asyncio as aioredis
+
+    async def run() -> list[str]:
+        redis = aioredis.from_url(url)
+        try:
+            names = {text(n) for n in await redis.smembers(REGISTRY)}
+            if not names:
+                async for key in redis.scan_iter(match="saq:*:incomplete", count=1000):
+                    names.add(text(key)[len("saq:") : -len(":incomplete")])
+            return sorted(names)
+        finally:
+            await redis.aclose()
+
+    return asyncio.run(run())
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="SAQ Board dashboard")
+    parser.add_argument("--url", default=os.environ.get("SAQ_BOARD_URL"),
+                        help="Redis url, eg: redis://localhost:6379 (env SAQ_BOARD_URL)")
+    parser.add_argument("--queue", "-q", action="append", default=[],
+                        help="Queue name to monitor, repeatable. Default: discover them")
+    parser.add_argument("--settings", "-s", action="append", default=[],
+                        help="SAQ worker settings whose queue to monitor, eg: app.worker.settings")
+    parser.add_argument("--host", default="0.0.0.0", help="Host to bind, defaults to 0.0.0.0")
+    parser.add_argument("--port", type=int, default=8080, help="Port, defaults to 8080")
+    parser.add_argument("--root-path", default="", help="Path prefix when behind a proxy")
+    parser.add_argument("--read-only", action="store_true", help="Hide and reject every action")
+    args = parser.parse_args()
+
+    logging.basicConfig(level=logging.INFO)
+    sys.path.append(os.getcwd())
+
+    queues: list[Queue] = []
+    if args.settings:
+        from saq.worker import import_settings
+
+        queues += [import_settings(s).get("queue") or Queue.from_url("redis://localhost")
+                   for s in args.settings]
+    if args.url:
+        names = args.queue or discover(args.url) or ["default"]
+        queues += [Queue.from_url(args.url, name=name) for name in names]
+    if not queues:
+        parser.error("pass --url or --settings")
+
+    from aiohttp import web
+
+    from saq_board.web.aiohttp import create_app
+
+    app = create_app(queues, root_path=args.root_path, read_only=args.read_only)
+
+    async def disconnect(_app: web.Application) -> None:
+        for queue in queues:
+            await queue.disconnect()
+
+    app.on_shutdown.append(disconnect)
+    logging.info("Monitoring queues: %s", ", ".join(q.name for q in queues))
+    web.run_app(app, host=args.host, port=args.port)
+
+
+if __name__ == "__main__":
+    main()