kanbot 0.1.0__tar.gz

kanbot-0.1.0/.gitignore

@@ -0,0 +1,12 @@
+.venv/
+__pycache__/
+*.pyc
+*.db
+*.db-wal
+*.db-shm
+.deckhand/
+dist/
+build/
+*.egg-info/
+.vercel
+.vercel/

kanbot-0.1.0/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: kanbot
+Version: 0.1.0
+Summary: A Kanban board where every card is a task run by your local CLI coding agents (Claude, Codex, Gemini, GLM/ZAI, or any CLI you define).
+Project-URL: Homepage, https://github.com/yourname/deckhand
+Author: Deckhand
+License: MIT
+Keywords: agents,automation,claude,cli,codex,kanban
+Requires-Python: >=3.9
+Requires-Dist: fastapi>=0.110
+Requires-Dist: httpx>=0.27
+Requires-Dist: rich>=13.0
+Requires-Dist: uvicorn[standard]>=0.27
+Requires-Dist: websockets>=12.0
+Description-Content-Type: text/markdown
+
+# KanBot
+
+**A visual control room for your coding-agent TUIs — and a Kanban board where every card is a task run by them.**
+
+You run a lot of terminal coding agents (Claude Code, Codex, …). KanBot gives you
+one screen to *see what every session is doing*, pick any of them back up, and
+drop new tasks that agents run for you — with live logs streamed straight to the
+card.
+
+Two things in one board:
+
+1. **Track your TUIs.** A background runner watches each agent's local session
+   store and surfaces every session as a card: the project, the latest message,
+   how many turns, how long it's been brewing, and whether it's **working right
+   now**. Sessions flow by recency — working → **Running**, just-finished →
+   **Done**, older → **Backlog**.
+2. **Run new tasks.** Drop a card, pick an agent, and the runner executes it and
+   streams stdout/stderr to the card. Or drag any tracked session into **Running**
+   to resume it (`claude --resume`, `codex exec resume`).
+
+```
+ Backlog            Running            Review      Done
+ (stale sessions    (sessions          (your       (recently
+  + new tasks)       working now        finished    finished
+                     + running tasks)   tasks)       sessions)
+        │  drag → Running, or "Run", queues for a runner
+        ▼
+   ╔══════════════════════════════╗
+   ║  kanbot runner (background)   ║  detects claude · codex · gemini · glm · shell
+   ║  watches ~/.claude, ~/.codex  ║  executes & resumes, streams logs back
+   ╚══════════════════════════════╝
+```
+
+## Quickstart
+
+Easiest (isolated, sidesteps Homebrew's PEP 668 `externally-managed` error):
+
+```bash
+pipx install kanbot && kanbot up     # or zero-install:  uvx kanbot up
+```
+
+From source (until it's on PyPI):
+
+```bash
+python3 -m venv .venv && . .venv/bin/activate
+pip install -e .
+kanbot up                             # server + local runner, board at :8787
+```
+
+> Don't use bare `pip install` on macOS Homebrew Python — it errors with
+> `externally-managed-environment` (PEP 668). `pipx`/`uv` handle the env for you.
+
+The board immediately fills with your recent Claude/Codex sessions. Click any one
+to see its recent transcript in a terminal view and **resume** it; or hit
+**+ add task** to give an agent fresh work.
+
+Run the pieces separately (e.g. runner on another machine):
+
+```bash
+kanbot server                                   # the board / API
+kanbot runner --server http://HOST:8787 --name gpu-box
+```
+
+## Tracking other agents (Hermes, OpenCode, your own…)
+
+Claude Code and Codex are tracked out of the box. Any agent that logs
+newline-delimited JSON transcripts can be added with **no code change** — point
+KanBot at its store in `~/.kanbot/config.json` (a.k.a. `~/.kanbot/config.json`):
+
+```json
+{
+  "discovery_sources": [
+    {
+      "name": "hermes",
+      "label": "Hermes",
+      "root": "~/.hermes/sessions",
+      "pattern": "*.jsonl",
+      "recursive": true,
+      "fmt": "claude"
+    }
+  ]
+}
+```
+
+- `fmt`: `"claude"` for flat records (`{type, message, cwd, timestamp}`) or
+  `"codex"` for payload-nested records (`{payload: {role, content, cwd}}`).
+- `kanbot agents` shows which trackers are active and where they read from.
+
+## Run agents
+
+`kanbot agents` lists the CLIs detected on this machine. Built-in catalog:
+
+| agent | run | resume |
+|-------|-----|--------|
+| `claude` | `claude -p "<prompt>"` | `claude --resume <id> -p "<prompt>"` |
+| `codex` | `codex exec --full-auto "<prompt>"` | `codex exec resume <id> "<prompt>"` |
+| `gemini` | `gemini -y -p "<prompt>"` | — |
+| `glm` | Claude Code w/ `ANTHROPIC_BASE_URL=https://api.z.ai/api/anthropic` | ✓ |
+| `opencode`, `aider`, `cursor-agent`, `hermes`, `shell` | see `kanbot/agents.py` | — |
+
+Override or add any agent's command in `~/.kanbot/config.json` →
+`agent_overrides`. A card set to `auto` runs on whatever the matched runner has.
+
+> Note: built-in run commands use auto-approve flags so tasks run unattended.
+> Review `kanbot/agents.py` and dial them back if you want a human in the loop.
+
+## Tags & insights
+
+Tags are colored labels; a tag can also be an **insight provider** (◆) that pulls
+live context onto any card: **git** (branch/diff), **files** (recent changes), or
+a **custom command** (e.g. `pytest -q`).
+
+## CLI
+
+```
+kanbot up         server + local runner (best first run)
+kanbot server     board / API only
+kanbot runner     background runner only  (--server, --name, --concurrency)
+kanbot agents     detected agents + active session trackers
+kanbot config     server URL, token, runner name, enable/disable agents
+kanbot open       open the board
+```
+
+Config: `~/.kanbot/config.json` · data: `~/.kanbot/kanbot.db`.
+Set `KANBOT_TOKEN` on the server to require a matching `--token` from runners.
+
+## License
+
+MIT

kanbot-0.1.0/README.md

@@ -0,0 +1,129 @@
+# KanBot
+
+**A visual control room for your coding-agent TUIs — and a Kanban board where every card is a task run by them.**
+
+You run a lot of terminal coding agents (Claude Code, Codex, …). KanBot gives you
+one screen to *see what every session is doing*, pick any of them back up, and
+drop new tasks that agents run for you — with live logs streamed straight to the
+card.
+
+Two things in one board:
+
+1. **Track your TUIs.** A background runner watches each agent's local session
+   store and surfaces every session as a card: the project, the latest message,
+   how many turns, how long it's been brewing, and whether it's **working right
+   now**. Sessions flow by recency — working → **Running**, just-finished →
+   **Done**, older → **Backlog**.
+2. **Run new tasks.** Drop a card, pick an agent, and the runner executes it and
+   streams stdout/stderr to the card. Or drag any tracked session into **Running**
+   to resume it (`claude --resume`, `codex exec resume`).
+
+```
+ Backlog            Running            Review      Done
+ (stale sessions    (sessions          (your       (recently
+  + new tasks)       working now        finished    finished
+                     + running tasks)   tasks)       sessions)
+        │  drag → Running, or "Run", queues for a runner
+        ▼
+   ╔══════════════════════════════╗
+   ║  kanbot runner (background)   ║  detects claude · codex · gemini · glm · shell
+   ║  watches ~/.claude, ~/.codex  ║  executes & resumes, streams logs back
+   ╚══════════════════════════════╝
+```
+
+## Quickstart
+
+Easiest (isolated, sidesteps Homebrew's PEP 668 `externally-managed` error):
+
+```bash
+pipx install kanbot && kanbot up     # or zero-install:  uvx kanbot up
+```
+
+From source (until it's on PyPI):
+
+```bash
+python3 -m venv .venv && . .venv/bin/activate
+pip install -e .
+kanbot up                             # server + local runner, board at :8787
+```
+
+> Don't use bare `pip install` on macOS Homebrew Python — it errors with
+> `externally-managed-environment` (PEP 668). `pipx`/`uv` handle the env for you.
+
+The board immediately fills with your recent Claude/Codex sessions. Click any one
+to see its recent transcript in a terminal view and **resume** it; or hit
+**+ add task** to give an agent fresh work.
+
+Run the pieces separately (e.g. runner on another machine):
+
+```bash
+kanbot server                                   # the board / API
+kanbot runner --server http://HOST:8787 --name gpu-box
+```
+
+## Tracking other agents (Hermes, OpenCode, your own…)
+
+Claude Code and Codex are tracked out of the box. Any agent that logs
+newline-delimited JSON transcripts can be added with **no code change** — point
+KanBot at its store in `~/.kanbot/config.json` (a.k.a. `~/.kanbot/config.json`):
+
+```json
+{
+  "discovery_sources": [
+    {
+      "name": "hermes",
+      "label": "Hermes",
+      "root": "~/.hermes/sessions",
+      "pattern": "*.jsonl",
+      "recursive": true,
+      "fmt": "claude"
+    }
+  ]
+}
+```
+
+- `fmt`: `"claude"` for flat records (`{type, message, cwd, timestamp}`) or
+  `"codex"` for payload-nested records (`{payload: {role, content, cwd}}`).
+- `kanbot agents` shows which trackers are active and where they read from.
+
+## Run agents
+
+`kanbot agents` lists the CLIs detected on this machine. Built-in catalog:
+
+| agent | run | resume |
+|-------|-----|--------|
+| `claude` | `claude -p "<prompt>"` | `claude --resume <id> -p "<prompt>"` |
+| `codex` | `codex exec --full-auto "<prompt>"` | `codex exec resume <id> "<prompt>"` |
+| `gemini` | `gemini -y -p "<prompt>"` | — |
+| `glm` | Claude Code w/ `ANTHROPIC_BASE_URL=https://api.z.ai/api/anthropic` | ✓ |
+| `opencode`, `aider`, `cursor-agent`, `hermes`, `shell` | see `kanbot/agents.py` | — |
+
+Override or add any agent's command in `~/.kanbot/config.json` →
+`agent_overrides`. A card set to `auto` runs on whatever the matched runner has.
+
+> Note: built-in run commands use auto-approve flags so tasks run unattended.
+> Review `kanbot/agents.py` and dial them back if you want a human in the loop.
+
+## Tags & insights
+
+Tags are colored labels; a tag can also be an **insight provider** (◆) that pulls
+live context onto any card: **git** (branch/diff), **files** (recent changes), or
+a **custom command** (e.g. `pytest -q`).
+
+## CLI
+
+```
+kanbot up         server + local runner (best first run)
+kanbot server     board / API only
+kanbot runner     background runner only  (--server, --name, --concurrency)
+kanbot agents     detected agents + active session trackers
+kanbot config     server URL, token, runner name, enable/disable agents
+kanbot open       open the board
+```
+
+Config: `~/.kanbot/config.json` · data: `~/.kanbot/kanbot.db`.
+Set `KANBOT_TOKEN` on the server to require a matching `--token` from runners.
+
+## License
+
+MIT

kanbot-0.1.0/kanbot/__init__.py

@@ -0,0 +1,3 @@
+"""Deckhand — a Kanban board where every card is a task run by your local CLI coding agents."""
+
+__version__ = "0.1.0"

kanbot-0.1.0/kanbot/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

kanbot-0.1.0/kanbot/agents.py

@@ -0,0 +1,134 @@
+"""Built-in CLI agent catalog, shared by the server (display) and runner (execution).
+
+Each agent is defined declaratively so adding "whatever else is available in the
+CLI" is a one-liner here, or a config override on the runner side. The runner
+detects which `bin` are on PATH and only advertises those it finds.
+
+Command templates use Python str.format with:
+    {prompt}  -> the task prompt (already shell-safe; passed as a single argv item)
+The command is a list of argv tokens; the runner substitutes {prompt} per-token
+so no shell quoting is needed.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+
+@dataclass
+class AgentSpec:
+    name: str            # stable id, e.g. "claude"
+    label: str           # display name
+    bin: str             # executable to look for on PATH
+    argv: List[str]      # argv template; tokens may contain {prompt}
+    description: str = ""
+    env: Dict[str, str] = field(default_factory=dict)
+    color: str = "#8b5cf6"
+    # argv template to resume/continue an existing agent session. Tokens may
+    # contain {prompt} and {session_id}. Empty => resume not supported.
+    resume_argv: List[str] = field(default_factory=list)
+
+
+# Non-interactive / headless invocations for each known coding CLI.
+BUILTIN_AGENTS: List[AgentSpec] = [
+    AgentSpec(
+        name="claude",
+        label="Claude Code",
+        bin="claude",
+        argv=["claude", "-p", "{prompt}", "--dangerously-skip-permissions"],
+        resume_argv=["claude", "--resume", "{session_id}", "-p", "{prompt}",
+                     "--dangerously-skip-permissions"],
+        description="Anthropic Claude Code in headless print mode.",
+        color="#d97757",
+    ),
+    AgentSpec(
+        name="codex",
+        label="Codex",
+        bin="codex",
+        argv=["codex", "exec", "--sandbox", "workspace-write",
+              "--skip-git-repo-check", "{prompt}"],
+        resume_argv=["codex", "exec", "resume", "--skip-git-repo-check",
+                     "{session_id}", "{prompt}"],
+        description="OpenAI Codex CLI, non-interactive exec (workspace-write sandbox).",
+        color="#10a37f",
+    ),
+    AgentSpec(
+        name="gemini",
+        label="Gemini CLI",
+        bin="gemini",
+        argv=["gemini", "-y", "-p", "{prompt}"],
+        description="Google Gemini CLI in YOLO/auto mode.",
+        color="#4285f4",
+    ),
+    AgentSpec(
+        name="glm",
+        label="GLM / Z.ai",
+        bin="claude",
+        argv=["claude", "-p", "{prompt}", "--dangerously-skip-permissions"],
+        resume_argv=["claude", "--resume", "{session_id}", "-p", "{prompt}",
+                     "--dangerously-skip-permissions"],
+        description="Z.ai GLM coding plan via Claude Code (set ANTHROPIC_BASE_URL).",
+        env={"ANTHROPIC_BASE_URL": "https://api.z.ai/api/anthropic"},
+        color="#2563eb",
+    ),
+    AgentSpec(
+        name="opencode",
+        label="OpenCode",
+        bin="opencode",
+        argv=["opencode", "run", "{prompt}"],
+        description="OpenCode terminal agent, non-interactive run.",
+        color="#f59e0b",
+    ),
+    AgentSpec(
+        name="hermes",
+        label="Hermes",
+        bin="hermes",
+        argv=["hermes", "-p", "{prompt}"],
+        description="Hermes coding agent (best-effort; override argv in config if it differs).",
+        color="#e879f9",
+    ),
+    AgentSpec(
+        name="aider",
+        label="Aider",
+        bin="aider",
+        argv=["aider", "--yes", "--no-auto-commits", "--message", "{prompt}"],
+        description="Aider pair-programmer, single message mode.",
+        color="#22c55e",
+    ),
+    AgentSpec(
+        name="cursor-agent",
+        label="Cursor Agent",
+        bin="cursor-agent",
+        argv=["cursor-agent", "-p", "{prompt}"],
+        description="Cursor CLI agent in print mode.",
+        color="#000000",
+    ),
+    AgentSpec(
+        name="shell",
+        label="Shell command",
+        bin="bash",
+        argv=["bash", "-lc", "{prompt}"],
+        description="Run the prompt as a raw shell command. Always available.",
+        color="#64748b",
+    ),
+]
+
+BUILTIN_BY_NAME: Dict[str, AgentSpec] = {a.name: a for a in BUILTIN_AGENTS}
+
+
+def builtin_names() -> List[str]:
+    return [a.name for a in BUILTIN_AGENTS]
+
+
+def spec_to_dict(a: AgentSpec) -> dict:
+    return {
+        "name": a.name,
+        "label": a.label,
+        "bin": a.bin,
+        "description": a.description,
+        "color": a.color,
+    }
+
+
+def catalog() -> List[dict]:
+    return [spec_to_dict(a) for a in BUILTIN_AGENTS]

kanbot-0.1.0/kanbot/cli.py

@@ -0,0 +1,260 @@
+"""KanBot command-line interface.
+
+  kanbot up            # start server + a local runner together (best first run)
+  kanbot server        # just the web server / API / board
+  kanbot runner        # just the background runner (connects to a server)
+  kanbot agents        # show which CLI coding agents are detected here
+  kanbot config        # view / set server URL, token, runner name
+  kanbot open          # open the board in your browser
+"""
+from __future__ import annotations
+
+import argparse
+import asyncio
+import sys
+import threading
+import time
+import webbrowser
+
+from . import __version__
+from .config import Config, config_path, db_path
+
+
+def _rich():
+    try:
+        from rich.console import Console
+        return Console()
+    except Exception:
+        return None
+
+
+def cmd_server(args) -> int:
+    import uvicorn
+    from .server.app import create_app
+
+    app = create_app(db_path=args.db)
+    url = f"http://{args.host}:{args.port}"
+    print(f"KanBot server v{__version__}  →  {url}")
+    print(f"  db:    {args.db or db_path()}")
+    print(f"  open:  {url}  (then run `kanbot runner` on any machine)")
+    uvicorn.run(app, host=args.host, port=args.port, log_level=args.log_level)
+    return 0
+
+
+def cmd_runner(args) -> int:
+    from .runner.worker import Runner
+
+    cfg = Config.load()
+    if args.server:
+        cfg.server_url = args.server
+    if args.token:
+        cfg.token = args.token
+    if args.name:
+        cfg.runner_name = args.name
+    if args.concurrency:
+        cfg.max_concurrency = args.concurrency
+    cfg.save()
+
+    runner = Runner(cfg)
+    try:
+        asyncio.run(runner.run_forever())
+    except KeyboardInterrupt:
+        print("\nrunner stopped.")
+    return 0
+
+
+def cmd_up(args) -> int:
+    """Start the server in-process and attach a local runner. One command demo."""
+    import uvicorn
+    from .runner.worker import Runner
+    from .server.app import create_app
+
+    app = create_app(db_path=args.db)
+    config = uvicorn.Config(app, host=args.host, port=args.port, log_level="warning")
+    server = uvicorn.Server(config)
+
+    def serve():
+        asyncio.run(server.serve())
+
+    t = threading.Thread(target=serve, daemon=True)
+    t.start()
+
+    # wait for the server to come up
+    import httpx
+    base = f"http://{args.host}:{args.port}"
+    for _ in range(50):
+        try:
+            httpx.get(base + "/api/health", timeout=0.5)
+            break
+        except Exception:
+            time.sleep(0.1)
+
+    print(f"KanBot is up  →  {base}")
+    if not args.no_open:
+        try:
+            webbrowser.open(base)
+        except Exception:
+            pass
+
+    cfg = Config.load()
+    cfg.server_url = base
+    if args.name:
+        cfg.runner_name = args.name
+    if args.concurrency:
+        cfg.max_concurrency = args.concurrency
+    cfg.save()
+    runner = Runner(cfg)
+    print(f"Local runner '{cfg.runner_name}' attaching with agents: "
+          f"{', '.join(runner.agents) or '(none — install claude/codex/etc.)'}")
+    print("Press Ctrl-C to stop.\n")
+    try:
+        asyncio.run(runner.run_forever())
+    except KeyboardInterrupt:
+        print("\nshutting down.")
+        server.should_exit = True
+    return 0
+
+
+def cmd_agents(args) -> int:
+    from .runner.agents import detect_agents
+    from .agents import BUILTIN_AGENTS
+
+    cfg = Config.load()
+    found = detect_agents(cfg)
+    console = _rich()
+    if console:
+        from rich.table import Table
+        table = Table(title="CLI agents on this machine")
+        table.add_column("agent")
+        table.add_column("status")
+        table.add_column("description")
+        for spec in BUILTIN_AGENTS:
+            ok = spec.name in found
+            disabled = spec.name in cfg.disabled_agents
+            status = "[green]available[/green]" if ok else (
+                "[yellow]disabled[/yellow]" if disabled else "[dim]not found[/dim]")
+            table.add_row(spec.name, status, spec.description)
+        console.print(table)
+    else:
+        for spec in BUILTIN_AGENTS:
+            mark = "✓" if spec.name in found else "·"
+            print(f" {mark} {spec.name:14} {spec.description}")
+    print(f"\nadvertised capabilities: {', '.join(found) or '(none)'}")
+
+    # Session trackers: which TUIs KanBot can see / revive.
+    from .runner.discovery import active_providers, builtin_providers
+    trackers = active_providers(cfg.discovery_sources)
+    active_names = {t["name"] for t in trackers}
+    print("\nsession trackers (TUIs KanBot watches):")
+    for p in builtin_providers():
+        mark = "✓" if p.name in active_names else "·"
+        state = "tracking" if p.name in active_names else "no sessions found"
+        print(f"  {mark} {p.label:14} {p.root}  [{state}]")
+    for t in trackers:
+        if t["name"] not in ("claude", "codex"):
+            print(f"  ✓ {t['label']:14} {t['root']}  [custom]")
+    print("\nTrack another agent: add to discovery_sources in "
+          f"{config_path()}, e.g.\n"
+          '  {"name": "hermes", "label": "Hermes", "root": "~/.hermes/sessions",\n'
+          '   "pattern": "*.jsonl", "recursive": true, "fmt": "claude"}')
+    return 0
+
+
+def cmd_config(args) -> int:
+    cfg = Config.load()
+    changed = False
+    if args.server:
+        cfg.server_url = args.server; changed = True
+    if args.token is not None:
+        cfg.token = args.token; changed = True
+    if args.name:
+        cfg.runner_name = args.name; changed = True
+    if args.concurrency:
+        cfg.max_concurrency = args.concurrency; changed = True
+    if args.disable:
+        for a in args.disable:
+            if a not in cfg.disabled_agents:
+                cfg.disabled_agents.append(a)
+        changed = True
+    if args.enable:
+        cfg.disabled_agents = [a for a in cfg.disabled_agents if a not in args.enable]
+        changed = True
+    if changed:
+        cfg.save()
+        print(f"saved {config_path()}")
+    print(f"server_url      : {cfg.server_url}")
+    print(f"token           : {'(set)' if cfg.token else '(none)'}")
+    print(f"runner_name     : {cfg.runner_name}")
+    print(f"runner_id       : {cfg.runner_id}")
+    print(f"max_concurrency : {cfg.max_concurrency}")
+    print(f"disabled_agents : {', '.join(cfg.disabled_agents) or '(none)'}")
+    return 0
+
+
+def cmd_open(args) -> int:
+    cfg = Config.load()
+    url = args.server or cfg.server_url
+    print(f"opening {url}")
+    webbrowser.open(url)
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="kanbot", description=__doc__,
+                                formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--version", action="version", version=f"kanbot {__version__}")
+    sub = p.add_subparsers(dest="cmd")
+
+    sp = sub.add_parser("up", help="start server + local runner (recommended first run)")
+    sp.add_argument("--host", default="127.0.0.1")
+    sp.add_argument("--port", type=int, default=8787)
+    sp.add_argument("--db", default=None)
+    sp.add_argument("--name", default=None, help="runner name")
+    sp.add_argument("--concurrency", type=int, default=None)
+    sp.add_argument("--no-open", action="store_true", help="don't open the browser")
+    sp.set_defaults(func=cmd_up)
+
+    sp = sub.add_parser("server", help="run the web server / API only")
+    sp.add_argument("--host", default="127.0.0.1")
+    sp.add_argument("--port", type=int, default=8787)
+    sp.add_argument("--db", default=None)
+    sp.add_argument("--log-level", default="info")
+    sp.set_defaults(func=cmd_server)
+
+    sp = sub.add_parser("runner", help="run the background runner only")
+    sp.add_argument("--server", default=None, help="server URL (e.g. http://host:8787)")
+    sp.add_argument("--token", default=None)
+    sp.add_argument("--name", default=None)
+    sp.add_argument("--concurrency", type=int, default=None)
+    sp.set_defaults(func=cmd_runner)
+
+    sp = sub.add_parser("agents", help="show detected CLI agents")
+    sp.set_defaults(func=cmd_agents)
+
+    sp = sub.add_parser("config", help="view or set configuration")
+    sp.add_argument("--server", default=None)
+    sp.add_argument("--token", default=None)
+    sp.add_argument("--name", default=None)
+    sp.add_argument("--concurrency", type=int, default=None)
+    sp.add_argument("--disable", nargs="*", help="agent names to disable")
+    sp.add_argument("--enable", nargs="*", help="agent names to re-enable")
+    sp.set_defaults(func=cmd_config)
+
+    sp = sub.add_parser("open", help="open the board in a browser")
+    sp.add_argument("--server", default=None)
+    sp.set_defaults(func=cmd_open)
+
+    return p
+
+
+def main(argv=None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if not getattr(args, "cmd", None):
+        parser.print_help()
+        return 0
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())