opencode-dashboard-server 0.1.1__tar.gz → 0.3.0__tar.gz

opencode_dashboard_server-0.3.0/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: opencode-dashboard-server
+Version: 0.3.0
+Summary: FastAPI aggregator over opencode's SQLite storage
+Project-URL: Homepage, https://github.com/GCS-ZHN/opencode-dashboard
+Project-URL: Repository, https://github.com/GCS-ZHN/opencode-dashboard
+Project-URL: Issues, https://github.com/GCS-ZHN/opencode-dashboard/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi<1,>=0.115
+Requires-Dist: uvicorn<1,>=0.30
+Requires-Dist: platformdirs<5,>=4
+Requires-Dist: PyYAML<7,>=6
+
+# opencode-dashboard-server
+
+FastAPI aggregation backend for the [opencode-dashboard](https://github.com/GCS-ZHN/opencode-dashboard)
+project. Reads opencode's local SQLite storage via the `opencode db` CLI and exposes a JSON + SSE
+API for the dashboard front end.
+
+## Install (PyPI)
+
+```bash
+pip install opencode-dashboard-server
+# or with uv:
+uv tool install opencode-dashboard-server
+```
+
+Requires:
+
+- **Python ≥ 3.10**
+- **`opencode` CLI** on the same host — the server shells out to `opencode db "<SQL>"` and never
+  opens the SQLite file directly (it's WAL-mode and actively written while opencode runs).
+
+## Quick start
+
+Configure once (interactive; writes `~/.config/opencode-dashboard/server.yaml`), then serve:
+
+```bash
+opencode-dashboard-server configure
+opencode-dashboard-server serve
+```
+
+`configure` walks you through `port` (default `8791`), `host` (default `0.0.0.0`),
+`cors_origins` (comma-separated; empty = built-in loopback whitelist), `poll_seconds`
+(default `5`), and `opencode_bin` (default `opencode`). Empty input keeps the default.
+
+`serve` accepts overrides: `--port N`, `--host H`, `--config PATH` (instead of the XDG file).
+Precedence for port/host: CLI flag > env `PORT`/`HOST` > config file > default.
+
+Run one aggregator per opencode host:
+
+```bash
+uvicorn app:app --port 8791
+```
+
+or directly with uvicorn (still works — reads env/defaults only). Run on more hosts with
+different ports (`8792`, `8793`, …) and list each in the front end's config (`opencode-dashboard configure`).
+Environment switches (used when no config file value is set):
+
+- `DASHBOARD_CORS_ORIGINS` — comma-separated CORS allow-list (defaults to the loopback dev origins `localhost/127.0.0.1:5173` and `:4173`; tighten or widen for your deployment).
+- `DASHBOARD_POLL_SECONDS` — SSE poll interval in seconds (default `5`).
+- `OPENCODE_BIN` — path to the `opencode` binary if it's not on `PATH`.
+
+## API
+
+- `GET /health` — liveness
+- `GET /overview` — whole-host aggregate (tokens by type + cost, session counts, `updatedAt`)
+- `GET /projects` — per-project rollups
+- `GET /projects/{id}` — one project's sessions (parent/child tree)
+- `GET /sessions/{id}` — per-model breakdown for one session (handles mid-conversation model switches)
+- `GET /stream` — SSE: `updated` events when the DB changes (polled ~5s)
+
+JSON is camelCase, timestamps are epoch-ms. Full contract in the repo's `API.md`.
+
+## From source (development)
+
+```bash
+git clone https://github.com/GCS-ZHN/opencode-dashboard
+cd opencode-dashboard/server
+uv sync          # install deps (fastapi, uvicorn) + dev (pytest, httpx)
+uv run pytest    # run tests
+uvx ruff check . # lint
+```

opencode_dashboard_server-0.3.0/README.md

@@ -0,0 +1,70 @@
+# opencode-dashboard-server
+
+FastAPI aggregation backend for the [opencode-dashboard](https://github.com/GCS-ZHN/opencode-dashboard)
+project. Reads opencode's local SQLite storage via the `opencode db` CLI and exposes a JSON + SSE
+API for the dashboard front end.
+
+## Install (PyPI)
+
+```bash
+pip install opencode-dashboard-server
+# or with uv:
+uv tool install opencode-dashboard-server
+```
+
+Requires:
+
+- **Python ≥ 3.10**
+- **`opencode` CLI** on the same host — the server shells out to `opencode db "<SQL>"` and never
+  opens the SQLite file directly (it's WAL-mode and actively written while opencode runs).
+
+## Quick start
+
+Configure once (interactive; writes `~/.config/opencode-dashboard/server.yaml`), then serve:
+
+```bash
+opencode-dashboard-server configure
+opencode-dashboard-server serve
+```
+
+`configure` walks you through `port` (default `8791`), `host` (default `0.0.0.0`),
+`cors_origins` (comma-separated; empty = built-in loopback whitelist), `poll_seconds`
+(default `5`), and `opencode_bin` (default `opencode`). Empty input keeps the default.
+
+`serve` accepts overrides: `--port N`, `--host H`, `--config PATH` (instead of the XDG file).
+Precedence for port/host: CLI flag > env `PORT`/`HOST` > config file > default.
+
+Run one aggregator per opencode host:
+
+```bash
+uvicorn app:app --port 8791
+```
+
+or directly with uvicorn (still works — reads env/defaults only). Run on more hosts with
+different ports (`8792`, `8793`, …) and list each in the front end's config (`opencode-dashboard configure`).
+Environment switches (used when no config file value is set):
+
+- `DASHBOARD_CORS_ORIGINS` — comma-separated CORS allow-list (defaults to the loopback dev origins `localhost/127.0.0.1:5173` and `:4173`; tighten or widen for your deployment).
+- `DASHBOARD_POLL_SECONDS` — SSE poll interval in seconds (default `5`).
+- `OPENCODE_BIN` — path to the `opencode` binary if it's not on `PATH`.
+
+## API
+
+- `GET /health` — liveness
+- `GET /overview` — whole-host aggregate (tokens by type + cost, session counts, `updatedAt`)
+- `GET /projects` — per-project rollups
+- `GET /projects/{id}` — one project's sessions (parent/child tree)
+- `GET /sessions/{id}` — per-model breakdown for one session (handles mid-conversation model switches)
+- `GET /stream` — SSE: `updated` events when the DB changes (polled ~5s)
+
+JSON is camelCase, timestamps are epoch-ms. Full contract in the repo's `API.md`.
+
+## From source (development)
+
+```bash
+git clone https://github.com/GCS-ZHN/opencode-dashboard
+cd opencode-dashboard/server
+uv sync          # install deps (fastapi, uvicorn) + dev (pytest, httpx)
+uv run pytest    # run tests
+uvx ruff check . # lint
+```

{opencode_dashboard_server-0.1.1 → opencode_dashboard_server-0.3.0}/app.py

@@ -6,6 +6,7 @@ Run:  uv run uvicorn app:app --reload
 import asyncio
 import json
 import logging
+import os
 import socket
 import subprocess
 from functools import lru_cache
@@ -19,28 +20,44 @@ from db import CliRunner
 
 logger = logging.getLogger("dashboard")
 
+# Comma-separated CORS allow-list; defaults to the loopback dev origins. Tight
+# by default so a random webpage can't exfiltrate local project/session data.
+def default_cors_origins() -> list[str]:
+    env = os.environ.get("DASHBOARD_CORS_ORIGINS", "").strip()
+    if env:
+        return [o.strip() for o in env.split(",") if o.strip()]
+    return [
+        "http://localhost:5173", "http://127.0.0.1:5173",
+        "http://localhost:4173", "http://127.0.0.1:4173",
+    ]
 
-@lru_cache(maxsize=1)
-def opencode_version() -> str:
+
+@lru_cache(maxsize=8)
+def opencode_version(executable: str = "opencode") -> str:
     try:
         return subprocess.run(
-            ["opencode", "--version"], capture_output=True, text=True, check=True
+            [executable, "--version"], capture_output=True, text=True, check=True
         ).stdout.strip()
     except (OSError, subprocess.CalledProcessError):
         return "unknown"  # e.g. CI without the opencode CLI; don't fail the request
 
 
-def create_app(runner=None) -> FastAPI:
-    runner = runner or CliRunner()
+def create_app(runner=None, cors_origins=None, poll_seconds=None, opencode_bin=None) -> FastAPI:
+    bin = opencode_bin or os.environ.get("OPENCODE_BIN") or "opencode"
+    if runner is None:
+        runner = CliRunner(executable=bin)
+    origins = cors_origins if cors_origins is not None else default_cors_origins()
+    if poll_seconds is None:
+        try:
+            poll_seconds = float(os.environ.get("DASHBOARD_POLL_SECONDS", "5"))
+        except ValueError:
+            poll_seconds = 5.0
     app = FastAPI(title="opencode token dashboard")
     # Loopback-only API; restrict origins so a random webpage can't exfiltrate
     # local project/session data from the browser (the client runs from Vite).
     app.add_middleware(
         CORSMiddleware,
-        allow_origins=[
-            "http://localhost:5173", "http://127.0.0.1:5173",
-            "http://localhost:4173", "http://127.0.0.1:4173",
-        ],
+        allow_origins=origins,
         allow_methods=["*"],
         allow_headers=["*"],
     )
@@ -56,14 +73,14 @@ def create_app(runner=None) -> FastAPI:
 
     @app.get("/health")
     def health():
-        return {"status": "ok", "version": opencode_version()}
+        return {"status": "ok", "version": opencode_version(bin)}
 
     @app.get("/overview")
     def overview():
         def run():
             data = aggregate.overview(runner)
             data["host"] = socket.gethostname()
-            data["opencodeVersion"] = opencode_version()
+            data["opencodeVersion"] = opencode_version(bin)
             return data
 
         return handle(run)
@@ -116,7 +133,7 @@ def create_app(runner=None) -> FastAPI:
                 except Exception:
                     logger.exception("stream poll failed")
                 try:
-                    await asyncio.wait_for(stop.wait(), 5)
+                    await asyncio.wait_for(stop.wait(), poll_seconds)
                 except asyncio.TimeoutError:
                     pass
 

opencode_dashboard_server-0.3.0/cli.py

@@ -0,0 +1,126 @@
+"""opencode-dashboard-server CLI: interactive configure + serve.
+
+Run:  uv tool install opencode-dashboard-server
+      opencode-dashboard-server configure
+      opencode-dashboard-server serve [--port N] [--host H] [--config PATH]
+"""
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+import yaml
+from platformdirs import user_config_path
+
+from app import create_app
+
+
+def config_path() -> Path:
+    # Force XDG semantics so the backend shares ~/.config/opencode-dashboard
+    # with the front end; platformdirs would otherwise use ~/Library/Application
+    # Support on macOS. setdefault keeps a user-set XDG_CONFIG_HOME intact.
+    os.environ.setdefault("XDG_CONFIG_HOME", str(Path.home() / ".config"))
+    return user_config_path("opencode-dashboard") / "server.yaml"
+
+
+def load_config(path: Path) -> dict:
+    if not path.exists():
+        return {}
+    return yaml.safe_load(path.read_text()) or {}
+
+
+def _prompt(label: str, current, default) -> str:
+    hint = current if current != "" else default
+    try:
+        value = input(f"{label} [{hint}]: ").strip()
+    except EOFError:
+        return hint
+    return value if value else hint
+
+
+def _prompt_num(label: str, current, default, conv):
+    while True:
+        try:
+            return conv(_prompt(label, current, default))
+        except ValueError:
+            print(f"Invalid {label}; enter a number.")
+
+
+def cmd_configure(args) -> None:
+    path = config_path()
+    existing = load_config(path)
+    cur = {
+        "port": existing.get("port", 8791),
+        "host": existing.get("host", "0.0.0.0"),
+        "cors_origins": existing.get("cors_origins", ""),
+        "poll_seconds": existing.get("poll_seconds", 5),
+        "opencode_bin": existing.get("opencode_bin", "opencode"),
+    }
+    if existing:
+        print(f"Current config at {path}:")
+        print(yaml.safe_dump(cur, sort_keys=False).rstrip())
+        print()
+    cur["port"] = _prompt_num("port", cur["port"], 8791, int)
+    cur["host"] = _prompt("host", cur["host"], "0.0.0.0")
+    cur["cors_origins"] = _prompt(
+        "cors_origins (comma-separated; empty = built-in loopback whitelist)",
+        cur["cors_origins"], "",
+    )
+    cur["poll_seconds"] = _prompt_num("poll_seconds", cur["poll_seconds"], 5, float)
+    cur["opencode_bin"] = _prompt("opencode_bin", cur["opencode_bin"], "opencode")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(yaml.safe_dump(cur, sort_keys=False))
+    print(f"Wrote {path}")
+
+
+def cmd_serve(args) -> None:
+    path = args.config or config_path()
+    cfg = load_config(path)
+    try:
+        port = args.port or int(os.environ.get("PORT") or cfg.get("port") or 8791)
+    except ValueError:
+        print(f"invalid port: {os.environ.get('PORT') or cfg.get('port')!r}")
+        sys.exit(2)
+    host = args.host or os.environ.get("HOST") or cfg.get("host") or "0.0.0.0"
+
+    import uvicorn
+
+    # cors_origins is stored comma-separated; create_app expects a list.
+    cors = [o.strip() for o in str(cfg.get("cors_origins", "")).split(",") if o.strip()]
+
+    uvicorn.run(
+        create_app(
+            cors_origins=cors or None,
+            poll_seconds=cfg.get("poll_seconds"),
+            opencode_bin=cfg.get("opencode_bin") or None,
+        ),
+        host=host,
+        port=port,
+    )
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="opencode-dashboard-server",
+        description="opencode token dashboard aggregation backend",
+    )
+    sub = parser.add_subparsers(dest="cmd")
+    sub.add_parser("configure", help="interactively write the XDG config file")
+    serve = sub.add_parser("serve", help="run the server (FastAPI + uvicorn)")
+    serve.add_argument("--config", metavar="PATH", help="config file (default: XDG server.yaml)")
+    serve.add_argument("--port", type=int, help="listen port")
+    serve.add_argument("--host", help="bind host")
+    args = parser.parse_args(argv)
+    if args.cmd == "configure":
+        cmd_configure(args)
+    elif args.cmd == "serve":
+        cmd_serve(args)
+    else:
+        parser.print_usage()
+        return 2
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{opencode_dashboard_server-0.1.1 → opencode_dashboard_server-0.3.0}/db.py

@@ -11,8 +11,12 @@ Two interchangeable runners over the same SQL surface:
 """
 
 import json
+import os
 import subprocess
 
+# opencode CLI binary; override for a non-PATH install (e.g. a brew cellar path).
+OPENCODE_BIN = os.environ.get("OPENCODE_BIN", "opencode")
+
 
 def _inline(sql: str, params: tuple) -> str:
     """Inline bound params into SQL as safely-quoted literals (CliRunner has no
@@ -29,8 +33,8 @@ def _inline(sql: str, params: tuple) -> str:
 
 
 class CliRunner:
-    def __init__(self, executable: str = "opencode"):
-        self._cmd = [executable, "db"]
+    def __init__(self, executable: str | None = None):
+        self._cmd = [executable or OPENCODE_BIN, "db"]
 
     def query(self, sql: str, params: tuple = ()) -> list[dict]:
         raw = subprocess.run(

opencode_dashboard_server-0.3.0/opencode_dashboard_server.egg-info/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: opencode-dashboard-server
+Version: 0.3.0
+Summary: FastAPI aggregator over opencode's SQLite storage
+Project-URL: Homepage, https://github.com/GCS-ZHN/opencode-dashboard
+Project-URL: Repository, https://github.com/GCS-ZHN/opencode-dashboard
+Project-URL: Issues, https://github.com/GCS-ZHN/opencode-dashboard/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi<1,>=0.115
+Requires-Dist: uvicorn<1,>=0.30
+Requires-Dist: platformdirs<5,>=4
+Requires-Dist: PyYAML<7,>=6
+
+# opencode-dashboard-server
+
+FastAPI aggregation backend for the [opencode-dashboard](https://github.com/GCS-ZHN/opencode-dashboard)
+project. Reads opencode's local SQLite storage via the `opencode db` CLI and exposes a JSON + SSE
+API for the dashboard front end.
+
+## Install (PyPI)
+
+```bash
+pip install opencode-dashboard-server
+# or with uv:
+uv tool install opencode-dashboard-server
+```
+
+Requires:
+
+- **Python ≥ 3.10**
+- **`opencode` CLI** on the same host — the server shells out to `opencode db "<SQL>"` and never
+  opens the SQLite file directly (it's WAL-mode and actively written while opencode runs).
+
+## Quick start
+
+Configure once (interactive; writes `~/.config/opencode-dashboard/server.yaml`), then serve:
+
+```bash
+opencode-dashboard-server configure
+opencode-dashboard-server serve
+```
+
+`configure` walks you through `port` (default `8791`), `host` (default `0.0.0.0`),
+`cors_origins` (comma-separated; empty = built-in loopback whitelist), `poll_seconds`
+(default `5`), and `opencode_bin` (default `opencode`). Empty input keeps the default.
+
+`serve` accepts overrides: `--port N`, `--host H`, `--config PATH` (instead of the XDG file).
+Precedence for port/host: CLI flag > env `PORT`/`HOST` > config file > default.
+
+Run one aggregator per opencode host:
+
+```bash
+uvicorn app:app --port 8791
+```
+
+or directly with uvicorn (still works — reads env/defaults only). Run on more hosts with
+different ports (`8792`, `8793`, …) and list each in the front end's config (`opencode-dashboard configure`).
+Environment switches (used when no config file value is set):
+
+- `DASHBOARD_CORS_ORIGINS` — comma-separated CORS allow-list (defaults to the loopback dev origins `localhost/127.0.0.1:5173` and `:4173`; tighten or widen for your deployment).
+- `DASHBOARD_POLL_SECONDS` — SSE poll interval in seconds (default `5`).
+- `OPENCODE_BIN` — path to the `opencode` binary if it's not on `PATH`.
+
+## API
+
+- `GET /health` — liveness
+- `GET /overview` — whole-host aggregate (tokens by type + cost, session counts, `updatedAt`)
+- `GET /projects` — per-project rollups
+- `GET /projects/{id}` — one project's sessions (parent/child tree)
+- `GET /sessions/{id}` — per-model breakdown for one session (handles mid-conversation model switches)
+- `GET /stream` — SSE: `updated` events when the DB changes (polled ~5s)
+
+JSON is camelCase, timestamps are epoch-ms. Full contract in the repo's `API.md`.
+
+## From source (development)
+
+```bash
+git clone https://github.com/GCS-ZHN/opencode-dashboard
+cd opencode-dashboard/server
+uv sync          # install deps (fastapi, uvicorn) + dev (pytest, httpx)
+uv run pytest    # run tests
+uvx ruff check . # lint
+```

{opencode_dashboard_server-0.1.1 → opencode_dashboard_server-0.3.0}/opencode_dashboard_server.egg-info/SOURCES.txt

@@ -1,11 +1,13 @@
 README.md
 aggregate.py
 app.py
+cli.py
 db.py
 pyproject.toml
 opencode_dashboard_server.egg-info/PKG-INFO
 opencode_dashboard_server.egg-info/SOURCES.txt
 opencode_dashboard_server.egg-info/dependency_links.txt
+opencode_dashboard_server.egg-info/entry_points.txt
 opencode_dashboard_server.egg-info/requires.txt
 opencode_dashboard_server.egg-info/top_level.txt
 tests/test_aggregate.py

opencode_dashboard_server-0.3.0/opencode_dashboard_server.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+opencode-dashboard-server = cli:main

{opencode_dashboard_server-0.1.1 → opencode_dashboard_server-0.3.0}/opencode_dashboard_server.egg-info/requires.txt

@@ -1,2 +1,4 @@
 fastapi<1,>=0.115
 uvicorn<1,>=0.30
+platformdirs<5,>=4
+PyYAML<7,>=6

{opencode_dashboard_server-0.1.1 → opencode_dashboard_server-0.3.0}/opencode_dashboard_server.egg-info/top_level.txt

@@ -1,3 +1,4 @@
 aggregate
 app
+cli
 db

{opencode_dashboard_server-0.1.1 → opencode_dashboard_server-0.3.0}/pyproject.toml

@@ -4,20 +4,27 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opencode-dashboard-server"
-version = "0.1.1"
+version = "0.3.0"
 description = "FastAPI aggregator over opencode's SQLite storage"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
     "fastapi>=0.115,<1",
     "uvicorn>=0.30,<1",
+    "platformdirs>=4,<5",
+    "PyYAML>=6,<7",
 ]
 
 [project.urls]
 Homepage = "https://github.com/GCS-ZHN/opencode-dashboard"
+Repository = "https://github.com/GCS-ZHN/opencode-dashboard"
+Issues = "https://github.com/GCS-ZHN/opencode-dashboard/issues"
+
+[project.scripts]
+opencode-dashboard-server = "cli:main"
 
 [tool.setuptools]
-py-modules = ["app", "aggregate", "db"]
+py-modules = ["app", "aggregate", "db", "cli"]
 
 [dependency-groups]
 dev = [

{opencode_dashboard_server-0.1.1 → opencode_dashboard_server-0.3.0}/tests/test_app.py

@@ -46,3 +46,15 @@ def test_foreign_origin_not_allowed_by_cors():
         "Access-Control-Request-Method": "GET",
     })
     assert "access-control-allow-origin" not in r.headers
+
+
+def test_cors_origins_injection():
+    conn = sqlite3.connect(":memory:", check_same_thread=False)
+    conn.executescript(SCHEMA)
+    seed(conn)
+    app = appmod.create_app(SqliteRunner(conn), cors_origins=["http://a.com"])
+    c = TestClient(app)
+    ok = c.options("/projects", headers={"Origin": "http://a.com", "Access-Control-Request-Method": "GET"})
+    assert ok.headers.get("access-control-allow-origin") == "http://a.com"
+    nope = c.options("/projects", headers={"Origin": "http://a.co", "Access-Control-Request-Method": "GET"})
+    assert "access-control-allow-origin" not in nope.headers

opencode_dashboard_server-0.1.1/PKG-INFO

@@ -1,54 +0,0 @@
-Metadata-Version: 2.4
-Name: opencode-dashboard-server
-Version: 0.1.1
-Summary: FastAPI aggregator over opencode's SQLite storage
-Project-URL: Homepage, https://github.com/GCS-ZHN/opencode-dashboard
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-Requires-Dist: fastapi<1,>=0.115
-Requires-Dist: uvicorn<1,>=0.30
-
-# opencode-dashboard-server
-
-FastAPI aggregation backend for the [opencode-dashboard](https://github.com/GCS-ZHN/opencode-dashboard)
-project. Reads opencode's local SQLite storage via the `opencode db` CLI and exposes a JSON + SSE
-API for the dashboard front end.
-
-## Install
-
-```bash
-pip install opencode-dashboard-server
-```
-
-Requires Python ≥ 3.10 and the `opencode` CLI on the same host (the server shells out to
-`opencode db "<SQL>"` — it never opens the SQLite file directly, which is WAL-mode and actively
-written while opencode runs).
-
-## Usage
-
-On each host that runs opencode:
-
-```bash
-uvicorn app:app --port 8791
-```
-
-Run on more hosts with different ports (`8792`, `8793`, …) and point the front end at each.
-
-## API
-
-- `GET /health` — liveness
-- `GET /overview` — whole-host aggregate (tokens by type + cost, session counts, `updatedAt`)
-- `GET /projects` — per-project rollups
-- `GET /projects/{id}` — one project's sessions (parent/child tree)
-- `GET /sessions/{id}` — per-model breakdown for one session (handles mid-conversation model switches)
-- `GET /stream` — SSE: `updated` events when the DB changes (polled ~5s)
-
-JSON is camelCase, timestamps are epoch-ms. Full contract in the repo's `API.md`.
-
-## Development
-
-```bash
-uv sync          # install deps (fastapi, uvicorn) + dev (pytest, httpx)
-uv run pytest    # run tests
-uvx ruff check . # lint
-```

opencode_dashboard_server-0.1.1/README.md

@@ -1,44 +0,0 @@
-# opencode-dashboard-server
-
-FastAPI aggregation backend for the [opencode-dashboard](https://github.com/GCS-ZHN/opencode-dashboard)
-project. Reads opencode's local SQLite storage via the `opencode db` CLI and exposes a JSON + SSE
-API for the dashboard front end.
-
-## Install
-
-```bash
-pip install opencode-dashboard-server
-```
-
-Requires Python ≥ 3.10 and the `opencode` CLI on the same host (the server shells out to
-`opencode db "<SQL>"` — it never opens the SQLite file directly, which is WAL-mode and actively
-written while opencode runs).
-
-## Usage
-
-On each host that runs opencode:
-
-```bash
-uvicorn app:app --port 8791
-```
-
-Run on more hosts with different ports (`8792`, `8793`, …) and point the front end at each.
-
-## API
-
-- `GET /health` — liveness
-- `GET /overview` — whole-host aggregate (tokens by type + cost, session counts, `updatedAt`)
-- `GET /projects` — per-project rollups
-- `GET /projects/{id}` — one project's sessions (parent/child tree)
-- `GET /sessions/{id}` — per-model breakdown for one session (handles mid-conversation model switches)
-- `GET /stream` — SSE: `updated` events when the DB changes (polled ~5s)
-
-JSON is camelCase, timestamps are epoch-ms. Full contract in the repo's `API.md`.
-
-## Development
-
-```bash
-uv sync          # install deps (fastapi, uvicorn) + dev (pytest, httpx)
-uv run pytest    # run tests
-uvx ruff check . # lint
-```

opencode_dashboard_server-0.1.1/opencode_dashboard_server.egg-info/PKG-INFO

@@ -1,54 +0,0 @@
-Metadata-Version: 2.4
-Name: opencode-dashboard-server
-Version: 0.1.1
-Summary: FastAPI aggregator over opencode's SQLite storage
-Project-URL: Homepage, https://github.com/GCS-ZHN/opencode-dashboard
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-Requires-Dist: fastapi<1,>=0.115
-Requires-Dist: uvicorn<1,>=0.30
-
-# opencode-dashboard-server
-
-FastAPI aggregation backend for the [opencode-dashboard](https://github.com/GCS-ZHN/opencode-dashboard)
-project. Reads opencode's local SQLite storage via the `opencode db` CLI and exposes a JSON + SSE
-API for the dashboard front end.
-
-## Install
-
-```bash
-pip install opencode-dashboard-server
-```
-
-Requires Python ≥ 3.10 and the `opencode` CLI on the same host (the server shells out to
-`opencode db "<SQL>"` — it never opens the SQLite file directly, which is WAL-mode and actively
-written while opencode runs).
-
-## Usage
-
-On each host that runs opencode:
-
-```bash
-uvicorn app:app --port 8791
-```
-
-Run on more hosts with different ports (`8792`, `8793`, …) and point the front end at each.
-
-## API
-
-- `GET /health` — liveness
-- `GET /overview` — whole-host aggregate (tokens by type + cost, session counts, `updatedAt`)
-- `GET /projects` — per-project rollups
-- `GET /projects/{id}` — one project's sessions (parent/child tree)
-- `GET /sessions/{id}` — per-model breakdown for one session (handles mid-conversation model switches)
-- `GET /stream` — SSE: `updated` events when the DB changes (polled ~5s)
-
-JSON is camelCase, timestamps are epoch-ms. Full contract in the repo's `API.md`.
-
-## Development
-
-```bash
-uv sync          # install deps (fastapi, uvicorn) + dev (pytest, httpx)
-uv run pytest    # run tests
-uvx ruff check . # lint
-```