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

{typefaster_cli-0.1.0 → typefaster_cli-0.1.1}/.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.0 → typefaster_cli-0.1.1}/.gitignore

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: typefaster-cli
-Version: 0.1.0
+Version: 0.1.1
 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.1}/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.0 → typefaster_cli-0.1.1}/client/typefaster/__init__.py

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

{typefaster_cli-0.1.0 → typefaster_cli-0.1.1}/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.1}/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.1}/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.1}/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.1}/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:

typefaster_cli-0.1.1/docs/online-setup.md

@@ -0,0 +1,106 @@
+# Going online — Cloudflare tunnel + OAuth login
+
+How to let a friend on another machine join your races, and (optionally) enable
+GitHub / Google login. Everything here is **free**.
+
+The model: your server runs locally (Colima → `localhost:8000`). A **tunnel**
+gives it a public `https://…` address. Friends point their client at that URL.
+
+---
+
+## 1. Start the server
+```bash
+cd typefaster-cli
+make up                      # redis + server on localhost:8000  (Colima)
+curl -s localhost:8000/healthz   # {"status":"ok"}
+```
+
+## 2. Expose it with a Cloudflare tunnel (free, no account)
+```bash
+brew install cloudflared
+cloudflared tunnel --url http://localhost:8000
+```
+It prints a public URL, e.g.:
+```
+https://brave-otter-1234.trycloudflare.com
+```
+Keep this terminal open — the tunnel lives as long as it runs. WebSockets work
+over it automatically (`https://` → `wss://`).
+
+> The free `trycloudflare.com` URL changes each run. For a stable address, use a
+> named tunnel (Cloudflare account, still free) or deploy to a VM (`deployment.md`).
+
+## 3. Point clients at the tunnel
+On **each** machine (yours and your friend's):
+```bash
+typefaster config set-server https://brave-otter-1234.trycloudflare.com
+typefaster config show
+```
+
+## 4. Play
+**You (host):**
+```bash
+typefaster register alice          # or: typefaster login --github
+typefaster lobby create --name "Friday" --time 60
+# waiting room shows the join code, e.g. 6AJ97X
+```
+**Friend (other machine):**
+```bash
+typefaster config set-server https://brave-otter-1234.trycloudflare.com
+typefaster register bob            # or login --github / --google
+typefaster lobby join 6AJ97X
+```
+Both: once you see each other in the room, press **R**. Server runs the
+countdown and the race. After, **R** plays again, **Esc** leaves.
+
+---
+
+## 5. (Optional) GitHub / Google login
+
+Username/password works out of the box. To add social login (device flow, the
+`gh auth login` experience), create the apps below and put the IDs in `.env`,
+then `make up` to restart.
+
+### GitHub (client id only — free)
+1. https://github.com/settings/developers → **New OAuth App**.
+2. Application name: `TYPEFASTER`; Homepage URL: your repo or tunnel URL;
+   Authorization callback URL: any valid URL (device flow doesn't use it, e.g.
+   the homepage).
+3. **Enable Device Flow** (checkbox on the app page) — required.
+4. Copy the **Client ID** into `.env`:
+   ```
+   TYPEFASTER_GITHUB_CLIENT_ID=Iv1.xxxxxxxx
+   ```
+   (No client secret needed for GitHub device flow.)
+
+### Google (client id + secret — free)
+1. https://console.cloud.google.com → create/select a project.
+2. **APIs & Services → OAuth consent screen** → External → fill basics → add
+   your email as a test user.
+3. **Credentials → Create credentials → OAuth client ID → "TVs and Limited
+   Input devices"**.
+4. Copy **Client ID** and **Client secret** into `.env`:
+   ```
+   TYPEFASTER_GOOGLE_CLIENT_ID=xxxx.apps.googleusercontent.com
+   TYPEFASTER_GOOGLE_CLIENT_SECRET=xxxx
+   ```
+
+### Apply + use
+```bash
+make up                # restart server with the new env
+typefaster login --github     # shows a code + opens github.com/login/device
+typefaster login --google     # shows a code + opens google.com/device
+```
+The CLI prints a short code and opens your browser; approve there and you're in.
+First social login auto-creates a TYPEFASTER account (username derived from your
+GitHub login / Google email).
+
+> Device flow needs **no public callback URL**, so it works behind the tunnel
+> and on `localhost` alike. Provider login is free; the only possible cost is a
+> server host if you later move off the tunnel (see `deployment.md`).
+
+## Stop everything
+```bash
+# Ctrl-C the cloudflared terminal
+make down            # stop redis + server
+```

{typefaster_cli-0.1.0 → typefaster_cli-0.1.1}/infra/redis/redis.conf

@@ -13,9 +13,12 @@ save 60 10000
 maxmemory 256mb
 maxmemory-policy volatile-lru
 
-# Only listen on the container network; never expose Redis publicly.
+# Listen on the internal Docker network so the server container can connect.
+# Redis is NOT published to the host or internet (no `ports:` mapping in
+# docker-compose.yml), so protected-mode is safely disabled here. Do not expose
+# 6379 publicly without also setting `requirepass`.
 bind 0.0.0.0
-protected-mode yes
+protected-mode no
 
 # Reduce log noise.
 loglevel notice

{typefaster_cli-0.1.0 → typefaster_cli-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "typefaster-cli"
-version = "0.1.0"
+version = "0.1.1"
 description = "A terminal-first typing game inspired by MonkeyType and TypeRacer."
 readme = "README.md"
 requires-python = ">=3.11"

{typefaster_cli-0.1.0 → typefaster_cli-0.1.1}/server/app/config.py

@@ -16,6 +16,11 @@ class Settings(BaseSettings):
     countdown_seconds: int = 3
     max_players_per_lobby: int = 8
 
+    # OAuth device-flow login (all free). Empty => that provider is disabled.
+    github_client_id: str = ""
+    google_client_id: str = ""
+    google_client_secret: str = ""  # Google device flow requires the secret
+
 
 def get_settings() -> Settings:
     return Settings()

{typefaster_cli-0.1.0 → typefaster_cli-0.1.1}/server/app/main.py

@@ -14,7 +14,7 @@ from .config import get_settings
 from .deps import resolve_token
 from .logging_config import configure_logging
 from .repositories import RedisRepository
-from .routers import auth, health, leaderboards, lobbies
+from .routers import auth, health, leaderboards, lobbies, oauth
 from .ws.manager import Hub
 
 log = logging.getLogger("typefaster.server")
@@ -56,6 +56,7 @@ def create_app() -> FastAPI:
     )
     app.include_router(health.router)
     app.include_router(auth.router)
+    app.include_router(oauth.router)
     app.include_router(lobbies.router)
     app.include_router(leaderboards.router)
 

{typefaster_cli-0.1.0 → typefaster_cli-0.1.1}/server/app/redis_keys.py

@@ -17,6 +17,11 @@ def session(jti: str) -> str:
     return f"session:{jti}"
 
 
+def oauth(provider: str, provider_id: str) -> str:
+    """STRING: maps an external identity (github/google + id) -> our username."""
+    return f"oauth:{provider}:{provider_id}"
+
+
 def lobby(code: str) -> str:
     """HASH: name, host, is_public, mode_seconds, status, created_at."""
     return f"lobby:{code}"