typefaster-cli 0.1.0__tar.gz → 0.1.2__tar.gz

{typefaster_cli-0.1.0 → typefaster_cli-0.1.2}/.env.example

@@ -11,3 +11,10 @@ TYPEFASTER_ACCESS_TOKEN_MINUTES=1440
 
 # Host port to expose the server on for local dev (nginx handles prod).
 SERVER_PORT=8000
+
+# ── OAuth device-flow login (optional, all free) ────────────────────────
+# Leave blank to disable a provider. See docs/online-setup.md for how to
+# create the GitHub OAuth App and Google OAuth client.
+TYPEFASTER_GITHUB_CLIENT_ID=
+TYPEFASTER_GOOGLE_CLIENT_ID=
+TYPEFASTER_GOOGLE_CLIENT_SECRET=

typefaster_cli-0.1.2/.github/dependabot.yml

@@ -0,0 +1,16 @@
+version: 2
+updates:
+  - package-ecosystem: pip
+    directory: "/"           # client (root pyproject)
+    schedule: { interval: weekly }
+    open-pull-requests-limit: 5
+  - package-ecosystem: pip
+    directory: "/server"
+    schedule: { interval: weekly }
+    open-pull-requests-limit: 5
+  - package-ecosystem: pip
+    directory: "/shared"
+    schedule: { interval: weekly }
+  - package-ecosystem: github-actions
+    directory: "/"
+    schedule: { interval: weekly }

{typefaster_cli-0.1.0 → typefaster_cli-0.1.2}/.github/workflows/ci.yml

@@ -66,6 +66,21 @@ jobs:
       - name: Test (pytest)
         run: cd server && pytest
 
+  audit:
+    name: dependency audit (pip-audit)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+      - run: python -m pip install pip-audit
+      - name: Audit client deps
+        run: pip-audit --strict --progress-spinner off . || true
+      - name: Audit server deps
+        run: pip-audit --strict --progress-spinner off ./server || true
+
   build:
     name: build wheel
     runs-on: ubuntu-latest

typefaster_cli-0.1.2/.github/workflows/codeql.yml

@@ -0,0 +1,23 @@
+name: CodeQL
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  schedule:
+    - cron: "0 6 * * 1"   # weekly
+
+jobs:
+  analyze:
+    runs-on: ubuntu-latest
+    permissions:
+      security-events: write
+      actions: read
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - uses: github/codeql-action/init@v3
+        with:
+          languages: python
+      - uses: github/codeql-action/analyze@v3

{typefaster_cli-0.1.0 → typefaster_cli-0.1.2}/.github/workflows/release.yml

@@ -13,6 +13,7 @@ on:
 permissions:
   contents: write   # create the GitHub Release
   id-token: write   # OIDC token for PyPI Trusted Publishing
+  packages: write   # push the server image to GHCR
 
 jobs:
   build:
@@ -53,3 +54,29 @@ jobs:
         with:
           generate_release_notes: true
           files: dist/*
+
+  server-image:
+    name: build & push server image (GHCR)
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ghcr.io/${{ github.repository_owner }}/typefaster-server
+          tags: |
+            type=semver,pattern={{version}}
+            type=raw,value=latest
+      - uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: server/Dockerfile
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}

{typefaster_cli-0.1.0 → typefaster_cli-0.1.2}/.gitignore

@@ -29,3 +29,4 @@ typefaster.db*
 .idea/
 .vscode/
 .DS_Store
+.env

{typefaster_cli-0.1.0 → typefaster_cli-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: typefaster-cli
-Version: 0.1.0
+Version: 0.1.2
 Summary: A terminal-first typing game inspired by MonkeyType and TypeRacer.
 Project-URL: Homepage, https://github.com/Anoshor/typefaster-cli
 Project-URL: Repository, https://github.com/Anoshor/typefaster-cli
@@ -49,18 +49,6 @@ typefaster
 
 ---
 
-## Status
-
-| Phase | Scope | State |
-|-------|-------|-------|
-| **Phase 1** | Offline experience: races, ghosts, profile, stats, history, daily challenge | ✅ **Implemented & tested** |
-| **Phase 2** | Online multiplayer: FastAPI + Redis + WebSockets, auth, lobbies, leaderboards, anti-cheat, Docker | ✅ **Implemented & tested** |
-
-Both phases are implemented. Offline play needs only `pip install`; online play
-adds a Dockerized server (see [Online play](#online-play-phase-2)).
-
----
-
 ## What Phase 1 delivers
 
 - **Instant offline races** — random quote, live WPM / accuracy / progress / timer.

{typefaster_cli-0.1.0 → typefaster_cli-0.1.2}/README.md

@@ -17,18 +17,6 @@ typefaster
 
 ---
 
-## Status
-
-| Phase | Scope | State |
-|-------|-------|-------|
-| **Phase 1** | Offline experience: races, ghosts, profile, stats, history, daily challenge | ✅ **Implemented & tested** |
-| **Phase 2** | Online multiplayer: FastAPI + Redis + WebSockets, auth, lobbies, leaderboards, anti-cheat, Docker | ✅ **Implemented & tested** |
-
-Both phases are implemented. Offline play needs only `pip install`; online play
-adds a Dockerized server (see [Online play](#online-play-phase-2)).
-
----
-
 ## What Phase 1 delivers
 
 - **Instant offline races** — random quote, live WPM / accuracy / progress / timer.

typefaster_cli-0.1.2/SECURITY.md

@@ -0,0 +1,28 @@
+# Security Policy
+
+## Supported versions
+The latest released version on PyPI (`typefaster-cli`) and the `main` branch
+receive security fixes.
+
+## Reporting a vulnerability
+Please **do not open a public issue** for security problems.
+
+Report privately via GitHub's **Security advisories**:
+<https://github.com/Anoshor/typefaster-cli/security/advisories/new>
+
+(or email the maintainer listed on the GitHub profile). Include steps to
+reproduce and impact. We aim to acknowledge within 72 hours and to ship a fix or
+mitigation promptly, crediting reporters who wish to be named.
+
+## Hardening notes (for self-hosters)
+- Run the server only behind TLS (the bundled nginx profile, or a TLS-terminating
+  platform like Fly.io). Never expose Redis publicly — keep it on the internal
+  network (`docker-compose.yml` does not publish 6379).
+- Set a strong `TYPEFASTER_JWT_SECRET` (e.g. `openssl rand -hex 32`); rotating it
+  invalidates all existing sessions.
+- Lock `TYPEFASTER_CORS_ORIGINS` to your real domain in production (default `*`).
+- Credential endpoints (`/auth/register`, `/auth/login`, OAuth start) are
+  per-IP rate limited; keep `--proxy-headers` enabled so the limiter sees real
+  client IPs behind a proxy.
+- Passwords are hashed with bcrypt; results are re-scored server-side with
+  anti-cheat before leaderboard writes.

{typefaster_cli-0.1.0 → typefaster_cli-0.1.2}/client/typefaster/__init__.py

@@ -1,3 +1,3 @@
 """TYPEFASTER-CLI — a terminal-first typing game."""
 
-__version__ = "0.1.0"
+__version__ = "0.1.2"

{typefaster_cli-0.1.0 → typefaster_cli-0.1.2}/client/typefaster/cli.py

@@ -190,6 +190,7 @@ app.command("login")(_online.login)
 app.command("logout")(_online.logout)
 app.command("leaderboard")(_online.leaderboard)
 app.add_typer(_online.lobby_app, name="lobby")
+app.add_typer(_online.config_app, name="config")
 
 
 if __name__ == "__main__":

{typefaster_cli-0.1.0 → typefaster_cli-0.1.2}/client/typefaster/net/api.py

@@ -64,6 +64,15 @@ class ApiClient:
     def logout(self) -> None:
         self._request("POST", "/auth/logout", headers=self._auth_headers())
 
+    # ── oauth device flow ──────────────────────────────────────────────
+    def oauth_start(self, provider: str) -> Any:
+        return self._request("POST", f"/auth/oauth/{provider}/start")
+
+    def oauth_poll(self, provider: str, device_code: str) -> Any:
+        return self._request(
+            "POST", f"/auth/oauth/{provider}/poll", json={"device_code": device_code}
+        )
+
     def me(self) -> Any:
         return self._request("GET", "/auth/me", headers=self._auth_headers())
 

{typefaster_cli-0.1.0 → typefaster_cli-0.1.2}/client/typefaster/net/commands.py

@@ -6,7 +6,10 @@ The online race UI is launched via the Textual app.
 
 from __future__ import annotations
 
+import contextlib
 import getpass
+import time
+import webbrowser
 
 import typer
 from rich.console import Console
@@ -46,8 +49,18 @@ def register(
         client.close()
 
 
-def login(username: str = typer.Argument(..., help="Your username.")) -> None:
-    """Log in to the server."""
+def login(
+    username: str | None = typer.Argument(None, help="Your username (password login)."),
+    github: bool = typer.Option(False, "--github", help="Log in with GitHub (browser)."),
+    google: bool = typer.Option(False, "--google", help="Log in with Google (browser)."),
+) -> None:
+    """Log in to the server (password, or --github / --google)."""
+    if github or google:
+        _oauth_login("github" if github else "google")
+        return
+    if not username:
+        console.print("[red]Provide a username, or use[/] --github / --google.")
+        raise typer.Exit(1)
     password = getpass.getpass("Password: ")
     client, session = _client()
     try:
@@ -63,6 +76,54 @@ def login(username: str = typer.Argument(..., help="Your username.")) -> None:
         client.close()
 
 
+def _oauth_login(provider: str) -> None:
+    """Run the OAuth device flow: show a code, open the browser, poll for token."""
+    client, session = _client()
+    try:
+        try:
+            start = client.oauth_start(provider)
+        except ApiError as exc:
+            console.print(f"[red]{provider.title()} login unavailable:[/] {exc.detail}")
+            raise typer.Exit(1) from exc
+
+        uri = start["verification_uri"]
+        code = start["user_code"]
+        device = start["device_code"]
+        interval = int(start.get("interval", 5))
+        deadline = time.time() + int(start.get("expires_in", 900))
+
+        console.print(
+            f"\n  Open [bold underline]{uri}[/]\n"
+            f"  Enter code: [bold cyan]{code}[/]\n"
+        )
+        with contextlib.suppress(Exception):
+            webbrowser.open(uri)
+        console.print("[grey58]Waiting for authorization…[/] (Ctrl-C to cancel)")
+
+        while time.time() < deadline:
+            time.sleep(interval)
+            try:
+                r = client.oauth_poll(provider, device)
+            except ApiError as exc:
+                console.print(f"[red]Login failed:[/] {exc.detail}")
+                raise typer.Exit(1) from exc
+            status_ = r.get("status")
+            if status_ == "pending":
+                continue
+            if status_ == "slow_down":
+                interval += 5
+                continue
+            session.token = r["access_token"]
+            session.username = r["username"]
+            session.save()
+            console.print(f"[green]Logged in as[/] [bold]{session.username}[/]")
+            return
+        console.print("[red]Login timed out — please try again.[/]")
+        raise typer.Exit(1)
+    finally:
+        client.close()
+
+
 def logout() -> None:
     """Log out and clear the local token."""
     client, session = _client()
@@ -105,6 +166,38 @@ def leaderboard(
         client.close()
 
 
+# ── config subcommands ────────────────────────────────────────────────
+config_app = typer.Typer(help="Client configuration (server URL, etc).", no_args_is_help=True)
+
+
+@config_app.command("set-server")
+def config_set_server(
+    url: str = typer.Argument(..., help="Server base URL, e.g. https://abc.trycloudflare.com"),
+) -> None:
+    """Point this client at a server (local, tunnel, or deployed)."""
+    session = Session.load()
+    new_url = url.rstrip("/")
+    if new_url != session.server_url:
+        # Tokens are server-specific — clear on change to avoid stale auth.
+        session.token = None
+        session.username = None
+    session.server_url = new_url
+    session.save()
+    console.print(f"[green]Server set to[/] [bold]{session.server_url}[/]. Now log in or register.")
+
+
+@config_app.command("show")
+def config_show() -> None:
+    """Show the current client configuration."""
+    s = Session.load()
+    table = Table(show_header=False)
+    table.add_column(style="grey58", justify="right")
+    table.add_column()
+    table.add_row("Server URL", s.server_url)
+    table.add_row("Logged in as", s.username or "[grey58]not logged in[/]")
+    console.print(table)
+
+
 # ── lobby subcommands ─────────────────────────────────────────────────
 lobby_app = typer.Typer(help="Multiplayer lobbies.", no_args_is_help=True)
 

{typefaster_cli-0.1.0 → typefaster_cli-0.1.2}/client/typefaster/net/token_store.py

@@ -15,7 +15,10 @@ def _auth_path() -> Path:
 
 @dataclass(slots=True)
 class Session:
-    server_url: str = "http://localhost:8000"
+    # Default points at the public TYPEFASTER server so a fresh install can
+    # register/play with zero config. Override with `typefaster config set-server`
+    # (e.g. a local server or your own deployment).
+    server_url: str = "https://typefaster-cli.fly.dev"
     token: str | None = None
     username: str | None = None
 

{typefaster_cli-0.1.0 → typefaster_cli-0.1.2}/client/typefaster/ui/screens/online_race.py

@@ -1,8 +1,8 @@
-"""Online multiplayer race screen.
+"""Online multiplayer lobby + race screen.
 
-Connects to the server over WebSocket, auto-readies, and lets the **server**
-drive countdown/start/finish. The client only renders state, reports progress,
-and submits a final result for server-side validation.
+Flow: connect → wait in the lobby (press R to ready) → the **server** starts the
+race when everyone is ready, sends the same quote to all, relays progress, and
+re-scores results server-side. The client only renders state and reports input.
 """
 
 from __future__ import annotations
@@ -23,13 +23,14 @@ from textual.screen import Screen
 from textual.widgets import Static
 
 from ...domain.typing_engine import TypingEngine
+from ..widgets import bigtext
 from ..widgets.live_stats import LiveStats
 from ..widgets.typing_field import TypingField
 
 
-def _bar(pct: float, width: int = 24) -> str:
+def _bar(pct: float, width: int = 28) -> str:
     filled = max(0, min(width, round(pct / 100.0 * width)))
-    return "#" * filled + "-" * (width - filled)
+    return "█" * filled + "─" * (width - filled)
 
 
 class OnlineRaceScreen(Screen[None]):
@@ -40,23 +41,28 @@ class OnlineRaceScreen(Screen[None]):
         self.ws_url = ws_url
         self.username = username
         self.mode_seconds = mode_seconds
+        # Extract the lobby code from .../ws/lobby/<code>?token=...
+        self.code = ws_url.split("/ws/lobby/", 1)[-1].split("?", 1)[0]
         self.engine: TypingEngine | None = None
         self._ws: Any = None
         self._start_ms: int | None = None
+        self._phase = "lobby"  # lobby | racing | results
         self._typing = False
         self._finished = False
+        self._ready = False
+        self._roster: list[dict[str, Any]] = []
         self._opponents: dict[str, dict[str, float]] = {}
         self._status = "Connecting…"
         self._standings: list[dict[str, Any]] | None = None
 
     def compose(self) -> ComposeResult:
         with Vertical(id="race-wrap"):
-            yield Static("", id="net-status", classes="dim")
+            yield Static("", id="net-status")
             yield LiveStats()
             yield TypingField()
             with VerticalScroll():
                 yield Static("", id="bars")
-            yield Static("esc to leave", classes="dim")
+            yield Static("R ready   ·   esc leave", classes="dim")
 
     def on_mount(self) -> None:
         self.query_one(LiveStats).display = False
@@ -70,13 +76,12 @@ class OnlineRaceScreen(Screen[None]):
         try:
             async with websockets.connect(self.ws_url) as ws:
                 self._ws = ws
-                self._status = "Connected. Waiting for players to ready up…"
+                self._status = "In lobby — press [bold]R[/] when ready."
                 self._render_status()
-                await ws.send(json.dumps({"type": "SET_READY", "data": {"ready": True}}))
                 async for raw in ws:
                     self._handle(json.loads(raw))
         except Exception as exc:
-            self._status = f"Disconnected: {exc}"
+            self._status = f"[red]Disconnected:[/] {exc}"
             self._render_status()
 
     async def _send(self, type_: str, **data: Any) -> None:
@@ -87,10 +92,17 @@ class OnlineRaceScreen(Screen[None]):
     def _handle(self, msg: dict[str, Any]) -> None:
         etype = msg.get("type")
         data = msg.get("data", {})
-        if etype == "RACE_COUNTDOWN":
+        if etype == "LOBBY_UPDATE":
+            self._roster = data.get("players", [])
+            # Only repaint the lobby in the lobby phase — never clobber the
+            # results screen with the post-race "reset to waiting" update.
+            if self._phase == "lobby":
+                self._render_lobby(data)
+        elif etype == "RACE_COUNTDOWN":
             self._status = f"Race starts in {data.get('count')}…"
             self._render_status()
         elif etype == "RACE_START":
+            self._phase = "racing"
             self._begin(data["text"])
         elif etype == "RACE_PROGRESS":
             user = data.get("username")
@@ -99,9 +111,11 @@ class OnlineRaceScreen(Screen[None]):
                     "progress": float(data.get("progress", 0)),
                     "wpm": float(data.get("wpm", 0)),
                 }
-                self._render_bars()
+                if self._typing:
+                    self._render_bars()
         elif etype == "RACE_FINISHED":
             if data.get("final"):
+                self._phase = "results"
                 self._standings = data.get("standings", [])
                 self._show_standings()
             else:
@@ -109,16 +123,18 @@ class OnlineRaceScreen(Screen[None]):
                 if user and user != self.username:
                     self._opponents.setdefault(user, {})["progress"] = 100.0
                     self._render_bars()
-        elif etype == "CHAT_MESSAGE":
-            pass  # chat panel could render here
+        elif etype == "ERROR":
+            self._status = f"[red]{data.get('message', 'error')}[/]"
+            self._render_status()
 
     # ── race lifecycle ─────────────────────────────────────────────────
     def _begin(self, text: str) -> None:
         self.engine = TypingEngine(text)
         self._start_ms = int(time.time() * 1000)
         self._typing = True
-        self._status = "GO!"
-        self.query_one("#net-status", Static).display = False
+        self.query_one("#net-status", Static).update(
+            Text(bigtext.render("GO!"), justify="center", style="bold green")
+        )
         self.query_one(LiveStats).display = True
         self.query_one(TypingField).display = True
         self._render_field()
@@ -138,7 +154,6 @@ class OnlineRaceScreen(Screen[None]):
             seconds_left=seconds_left,
         )
         self._render_bars()
-        # Report progress to the server.
         self.run_worker(
             self._send(
                 "PROGRESS",
@@ -147,11 +162,25 @@ class OnlineRaceScreen(Screen[None]):
             ),
             name="progress",
         )
-        if (elapsed >= self.mode_seconds * 1000 or self.engine.finished) and not self._finished:
+        if self._start_ms is not None and elapsed >= self.mode_seconds * 1000 and not self._finished:
             self._submit_finish()
 
     def on_key(self, event: events.Key) -> None:
-        if not self._typing or self._finished or self.engine is None:
+        # Lobby phase: R toggles ready.
+        if self._phase == "lobby":
+            if event.key.lower() == "r":
+                self._ready = not self._ready
+                self.run_worker(self._send("SET_READY", ready=self._ready), name="ready")
+                event.stop()
+            return
+        # Results phase: R re-arms for another round.
+        if self._phase == "results":
+            if event.key.lower() == "r":
+                self._play_again()
+                event.stop()
+            return
+        # Race phase: type.
+        if self._finished or self.engine is None:
             return
         t = self._elapsed()
         if event.key == "backspace":
@@ -190,7 +219,34 @@ class OnlineRaceScreen(Screen[None]):
 
     # ── rendering ──────────────────────────────────────────────────────
     def _render_status(self) -> None:
-        self.query_one("#net-status", Static).update(Text(self._status, justify="center"))
+        self.query_one("#net-status", Static).update(Text.from_markup(self._status, justify="center"))
+
+    def _render_lobby(self, data: dict[str, Any]) -> None:
+        name = data.get("name", "Lobby")
+        host = data.get("host", "")
+        table = Table(title=f"{name}  ({self.mode_seconds}s)", title_style="bold", expand=True)
+        table.add_column("Player")
+        table.add_column("Ready", justify="center")
+        for p in self._roster:
+            who = p["username"] + (" 👑" if p["username"] == host else "")
+            who += "  (you)" if p["username"] == self.username else ""
+            ready = "[green]✓[/]" if p.get("ready") else "[grey58]…[/]"
+            table.add_row(who, ready)
+        ready_n = sum(1 for p in self._roster if p.get("ready"))
+        hint = Text.from_markup(
+            f"\n{ready_n}/{len(self._roster)} ready   ·   "
+            f"press [bold]R[/] to {'unready' if self._ready else 'ready'}   ·   "
+            "race starts when everyone is ready",
+            justify="center",
+        )
+        self.query_one("#bars", Static).update(Group(table, hint))
+        self.query_one("#net-status", Static).update(
+            Text.from_markup(
+                f"WAITING ROOM   ·   join code: [bold cyan]{self.code}[/]\n"
+                f"[grey58]share:[/] typefaster lobby join {self.code}",
+                justify="center",
+            )
+        )
 
     def _render_field(self) -> None:
         if self.engine is not None:
@@ -201,17 +257,17 @@ class OnlineRaceScreen(Screen[None]):
     def _render_bars(self) -> None:
         text = Text()
         me_pct = self.engine.progress * 100.0 if self.engine else 0.0
-        text.append("You    ", style="bold")
-        text.append(f"[{_bar(me_pct)}] {me_pct:3.0f}%\n", style="cyan")
+        text.append(f"{self.username[:9]:<9} ", style="bold cyan")
+        text.append(f"{_bar(me_pct)} {me_pct:3.0f}%\n", style="cyan")
         for name, st in sorted(self._opponents.items()):
             pct = st.get("progress", 0.0)
-            text.append(f"{name[:7]:<7}", style="bold")
-            text.append(f"[{_bar(pct)}] {pct:3.0f}%\n", style="magenta")
+            text.append(f"{name[:9]:<9} ", style="bold magenta")
+            text.append(f"{_bar(pct)} {pct:3.0f}%\n", style="magenta")
         self.query_one("#bars", Static).update(text)
 
     def _show_standings(self) -> None:
         self._typing = False
-        table = Table(title="Final Standings", title_style="bold")
+        table = Table(title="Final Standings", title_style="bold", expand=True)
         table.add_column("#", justify="right")
         table.add_column("Player")
         table.add_column("WPM", justify="right")
@@ -224,10 +280,30 @@ class OnlineRaceScreen(Screen[None]):
                 f"{row.get('wpm', 0):.0f}",
                 f"{row.get('accuracy', 0) * 100:.0f}%",
             )
+        self.query_one("#net-status", Static).update(
+            Text("RACE COMPLETE", justify="center", style="bold green")
+        )
         self.query_one("#net-status", Static).display = True
         self.query_one(TypingField).display = False
         self.query_one(LiveStats).display = False
-        self.query_one("#bars", Static).update(Group(table, Text("\nesc to leave", style="grey58")))
+        self.query_one("#bars", Static).update(
+            Group(table, Text("\nR play again   ·   esc leave", style="grey58"))
+        )
+
+    def _play_again(self) -> None:
+        """Re-arm for another round from the results screen."""
+        self._phase = "lobby"
+        self._typing = False
+        self._finished = False
+        self.engine = None
+        self._start_ms = None
+        self._opponents = {}
+        self._ready = True
+        self.query_one(LiveStats).display = False
+        self.query_one(TypingField).display = False
+        self._status = "Ready for next race — waiting for other players…"
+        self._render_status()
+        self.run_worker(self._send("SET_READY", ready=True), name="ready")
 
     # ── exit ───────────────────────────────────────────────────────────
     def action_leave(self) -> None:

{typefaster_cli-0.1.0 → typefaster_cli-0.1.2}/docker-compose.yml

@@ -33,6 +33,10 @@ services:
       TYPEFASTER_JWT_SECRET: ${TYPEFASTER_JWT_SECRET:?set a strong secret in .env}
       TYPEFASTER_CORS_ORIGINS: ${TYPEFASTER_CORS_ORIGINS:-*}
       TYPEFASTER_ACCESS_TOKEN_MINUTES: ${TYPEFASTER_ACCESS_TOKEN_MINUTES:-1440}
+      # OAuth device-flow login (optional; leave blank to disable a provider)
+      TYPEFASTER_GITHUB_CLIENT_ID: ${TYPEFASTER_GITHUB_CLIENT_ID:-}
+      TYPEFASTER_GOOGLE_CLIENT_ID: ${TYPEFASTER_GOOGLE_CLIENT_ID:-}
+      TYPEFASTER_GOOGLE_CLIENT_SECRET: ${TYPEFASTER_GOOGLE_CLIENT_SECRET:-}
     expose:
       - "8000"
     ports: