fcode 2.2.0__cp313-cp313-win_amd64.whl

fcode/api.py

@@ -0,0 +1,146 @@
+"""HTTP client helpers for fcode CLI — handles auth, errors, multipart."""
+
+import json
+import urllib.request
+import urllib.error
+from pathlib import Path
+
+from rich.console import Console
+
+from fcode.auth import get_api_url, get_token
+
+console = Console()
+
+
+class ApiError(Exception):
+    def __init__(self, message: str, status: int = 0):
+        self.message = message
+        self.status = status
+        super().__init__(message)
+
+
+def _require_token() -> str:
+    token = get_token()
+    if not token:
+        console.print("[red]Not logged in. Run: fcode login[/red]")
+        raise SystemExit(1)
+    return token
+
+
+def _handle_error(e: urllib.error.HTTPError) -> None:
+    try:
+        body = json.loads(e.read())
+        msg = body.get("error", str(e))
+    except Exception:
+        msg = str(e)
+
+    if e.code == 401:
+        console.print("[red]Session expired. Run: fcode login[/red]")
+    elif e.code == 429:
+        console.print(f"[yellow]Rate limited: {msg}[/yellow]")
+    elif e.code == 404:
+        console.print(f"[red]Not found: {msg}[/red]")
+    else:
+        console.print(f"[red]Error: {msg}[/red]")
+    raise SystemExit(1)
+
+
+def api_get(path: str, params: dict[str, str] | None = None) -> dict:
+    """Authenticated GET request. Returns parsed JSON."""
+    from urllib.parse import urlencode
+
+    token = _require_token()
+    api_url = get_api_url()
+    url = f"{api_url}{path}"
+    if params:
+        url += f"?{urlencode(params)}"
+
+    req = urllib.request.Request(
+        url,
+        headers={"Authorization": f"Bearer {token}"},
+        method="GET",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            return json.loads(resp.read())
+    except urllib.error.HTTPError as e:
+        _handle_error(e)
+        raise  # unreachable but satisfies type checker
+    except Exception as e:
+        console.print(f"[red]Request failed: {e}[/red]")
+        raise SystemExit(1)
+
+
+def api_post(path: str, body: dict) -> dict:
+    """Authenticated POST request with JSON body. Returns parsed JSON."""
+    token = _require_token()
+    api_url = get_api_url()
+
+    payload = json.dumps(body).encode()
+    req = urllib.request.Request(
+        f"{api_url}{path}",
+        data=payload,
+        headers={
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {token}",
+        },
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            return json.loads(resp.read())
+    except urllib.error.HTTPError as e:
+        _handle_error(e)
+        raise
+    except Exception as e:
+        console.print(f"[red]Request failed: {e}[/red]")
+        raise SystemExit(1)
+
+
+def api_post_multipart(
+    path: str,
+    files: dict[str, tuple[str, bytes, str]],
+    text_fields: dict[str, str] | None = None,
+    timeout: int = 60,
+) -> dict:
+    """Authenticated POST with multipart/form-data. Returns parsed JSON."""
+    token = _require_token()
+    api_url = get_api_url()
+
+    boundary = "----FcodeBoundary"
+    parts: list[bytes] = []
+    if text_fields:
+        for name, value in text_fields.items():
+            parts.append(f"--{boundary}\r\n".encode())
+            parts.append(f'Content-Disposition: form-data; name="{name}"\r\n\r\n'.encode())
+            parts.append(value.encode())
+            parts.append(b"\r\n")
+    for name, (filename, data, content_type) in files.items():
+        parts.append(f"--{boundary}\r\n".encode())
+        parts.append(
+            f'Content-Disposition: form-data; name="{name}"; filename="{filename}"\r\n'.encode()
+        )
+        parts.append(f"Content-Type: {content_type}\r\n\r\n".encode())
+        parts.append(data)
+        parts.append(b"\r\n")
+    parts.append(f"--{boundary}--\r\n".encode())
+    body = b"".join(parts)
+
+    req = urllib.request.Request(
+        f"{api_url}{path}",
+        data=body,
+        headers={
+            "Content-Type": f"multipart/form-data; boundary={boundary}",
+            "Authorization": f"Bearer {token}",
+        },
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return json.loads(resp.read())
+    except urllib.error.HTTPError as e:
+        _handle_error(e)
+        raise
+    except Exception as e:
+        console.print(f"[red]Upload failed: {e}[/red]")
+        raise SystemExit(1)

fcode/auth.py

@@ -0,0 +1,49 @@
+"""Credential storage for fcode CLI authentication."""
+
+import json
+from pathlib import Path
+
+CREDENTIALS_DIR = Path.home() / ".fcode"
+CREDENTIALS_FILE = CREDENTIALS_DIR / "credentials.json"
+
+# Patched to the platform URL at release build time; overridable via FCODE_API_URL env var
+DEFAULT_API_URL = "https://game.code.florent.vc"
+
+
+def get_api_url() -> str:
+    import os
+    return os.environ.get("FCODE_API_URL", DEFAULT_API_URL)
+
+
+def save_credentials(token: str, expires_at: str, user: dict, team: dict | None) -> None:
+    CREDENTIALS_DIR.mkdir(parents=True, exist_ok=True)
+    data = {
+        "token": token,
+        "expires_at": expires_at,
+        "user": user,
+        "team": team,
+    }
+    CREDENTIALS_FILE.write_text(json.dumps(data, indent=2))
+    # Restrict permissions to owner only
+    CREDENTIALS_FILE.chmod(0o600)
+
+
+def load_credentials() -> dict | None:
+    if not CREDENTIALS_FILE.exists():
+        return None
+    try:
+        return json.loads(CREDENTIALS_FILE.read_text())
+    except (json.JSONDecodeError, OSError):
+        return None
+
+
+def clear_credentials() -> None:
+    if CREDENTIALS_FILE.exists():
+        CREDENTIALS_FILE.unlink()
+
+
+def get_token() -> str | None:
+    creds = load_credentials()
+    if not creds:
+        return None
+    return creds.get("token")

fcode/cli.py

@@ -0,0 +1,127 @@
+import click
+from rich.console import Console
+
+from fcode import __version__
+from fcode.compat import deprecation_warning
+
+console = Console()
+
+@click.group()
+@click.version_option(version=__version__)
+def main():
+    """Florent Code League CLI"""
+    from fcode.version_check import check_for_update
+    latest = check_for_update()
+    if latest:
+        console.print(
+            f"[yellow]Update available: {__version__} -> {latest}. "
+            f"Run: pip install --upgrade fcode[/yellow]"
+        )
+
+# -- Unchanged top-level commands --
+from fcode.commands import run, watch, login, logout, starter, status, map_editor
+main.add_command(run.run)
+main.add_command(watch.watch)
+main.add_command(login.login)
+main.add_command(logout.logout)
+main.add_command(starter.starter)
+main.add_command(status.status)
+main.add_command(map_editor.map_editor)
+
+# -- New entity groups --
+from fcode.commands.submission import submission
+from fcode.commands.match_group import match as match_group
+from fcode.commands.team_group import team
+from fcode.commands.ladder import ladder
+main.add_command(submission)
+main.add_command(match_group)
+main.add_command(team)
+main.add_command(ladder)
+
+# -- submit as alias for submission upload --
+
+@click.command("submit")
+@click.argument("path", type=click.Path(exists=True))
+@click.option("--name", "-n", default=None, help="Optional name for this submission")
+def submit(path: str, name: str | None):
+    """Upload a bot to the platform (alias for `submission upload`)."""
+    from fcode.commands.submission import upload
+    ctx = click.get_current_context()
+    ctx.invoke(upload, path=path, name=name)
+
+main.add_command(submit)
+
+# -- Deprecated aliases (hidden, show warning) --
+
+@click.command("matches", hidden=True)
+@click.option("--type", "match_type", default=None, type=click.Choice(["ladder", "unrated"]))
+@click.option("--team", default=None)
+@click.option("--mine", is_flag=True)
+@click.option("--limit", default=20, type=int)
+@click.option("--cursor", default=None)
+def _dep_matches(match_type, team, mine, limit, cursor):
+    """Deprecated. Use: fcode match list"""
+    deprecation_warning("matches", "match list")
+    from fcode.commands.matches import _show_matches
+    _show_matches(match_type, team, limit, cursor, mine=mine)
+
+main.add_command(_dep_matches)
+
+
+@click.command("unrated", hidden=True)
+@click.argument("opponent_id")
+@click.option("--match", "source_match", default=None)
+@click.option("--map", "maps", multiple=True, help="Map name (repeatable, up to 5). Omit for random.")
+def _dep_unrated(opponent_id, source_match, maps):
+    """Deprecated. Use: fcode match unrated"""
+    deprecation_warning("unrated", "match unrated")
+    from fcode.commands.test import _show_unrated
+    _show_unrated(opponent_id, source_match, maps if maps else None)
+
+main.add_command(_dep_unrated)
+
+
+@click.command("test-run", hidden=True)
+@click.argument("bot_a")
+@click.argument("bot_b")
+@click.option("--map", "maps", multiple=True, help="Map name (repeatable, up to 5). Omit for random.")
+def _dep_test_run(bot_a, bot_b, maps):
+    """Deprecated. Use: fcode match test"""
+    deprecation_warning("test-run", "match test")
+    from fcode.commands.test_run import _show_test_run
+    _show_test_run(bot_a, bot_b, maps)
+
+main.add_command(_dep_test_run)
+
+
+@click.command("test-matches", hidden=True)
+@click.option("--limit", default=20, type=int)
+def _dep_test_matches(limit):
+    """Deprecated. Use: fcode match tests"""
+    deprecation_warning("test-matches", "match tests")
+    from fcode.commands.test_matches import _show_test_matches
+    _show_test_matches(limit)
+
+main.add_command(_dep_test_matches)
+
+
+# For `teams`, re-register the old group with a deprecation warning
+from fcode.commands.teams import teams as _teams_group
+
+class _DeprecatedTeamsGroup(click.Group):
+    def invoke(self, ctx):
+        deprecation_warning("teams", "team")
+        return super().invoke(ctx)
+
+_dep_teams = _DeprecatedTeamsGroup("teams", commands=_teams_group.commands, help="Deprecated. Use: fcode team", hidden=True)
+main.add_command(_dep_teams)
+
+
+@click.command("init", hidden=True)
+def _dep_init():
+    """Deprecated. Use: fcode starter"""
+    deprecation_warning("init", "starter")
+    from fcode.commands.init import init as _init_impl
+    click.get_current_context().invoke(_init_impl)
+
+main.add_command(_dep_init)

fcode/commands/init.py

@@ -0,0 +1,29 @@
+from pathlib import Path
+
+import click
+from rich.console import Console
+
+from fcode.config import CONFIG_FILENAME
+
+console = Console()
+
+DEFAULT_CONFIG = """\
+# fcode.toml — Florent Code League project config
+
+bots_dir = "bots"
+maps_dir = "maps"
+replay = "replay.replay26"
+seed = 1
+"""
+
+
+@click.command()
+def init():
+    """Initialize a fcode.toml config file in the current directory."""
+    config_path = Path.cwd() / CONFIG_FILENAME
+    if config_path.exists():
+        console.print(f"[yellow]{CONFIG_FILENAME} already exists.[/yellow]")
+        return
+
+    config_path.write_text(DEFAULT_CONFIG)
+    console.print(f"[green]Created {CONFIG_FILENAME}[/green]")

fcode/commands/ladder.py

@@ -0,0 +1,74 @@
+"""fcode ladder — view ladder rankings."""
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from fcode.api import api_get
+from fcode.auth import load_credentials
+
+console = Console()
+
+
+@click.command()
+@click.option("--limit", default=20, type=int, help="Number of teams to show")
+@click.option("--around", is_flag=True, help="Show rankings around your team (±5)")
+def ladder(limit: int, around: bool):
+    """View ladder rankings."""
+    data = api_get("/api/ladder")
+    rankings = data if isinstance(data, list) else data.get("rankings", data)
+
+    if not rankings:
+        console.print("[dim]No teams on the ladder yet.[/dim]")
+        return
+
+    # Add rank numbers before filtering (overall ladder position)
+    for i, r in enumerate(rankings):
+        r["_rank"] = i + 1
+
+    creds = load_credentials()
+    my_team_id = None
+    if creds and creds.get("team"):
+        my_team_id = creds["team"].get("id")
+
+    total_after_filter = len(rankings)
+
+    if around and my_team_id:
+        my_idx = next((i for i, r in enumerate(rankings) if r.get("teamId") == my_team_id), None)
+        if my_idx is not None:
+            start = max(0, my_idx - 5)
+            end = min(len(rankings), my_idx + 6)
+            rankings = rankings[start:end]
+        else:
+            console.print("[dim]Your team is not on the ladder.[/dim]")
+            return
+    else:
+        rankings = rankings[:limit]
+
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("#", justify="right", style="dim")
+    table.add_column("Team")
+    table.add_column("Rating", justify="right")
+    table.add_column("Matches", justify="right")
+
+    for r in rankings:
+        rank = str(r["_rank"])
+        name = r.get("teamName", "?")
+        is_mine = my_team_id and r.get("teamId") == my_team_id
+        if is_mine:
+            name = f"[bold cyan]{name}[/bold cyan]"
+            rank = f"[bold cyan]{rank}[/bold cyan]"
+
+        rating = f"{r.get('rating', 0):.0f}"
+        matches_played = str(r.get("matchesPlayed", 0))
+
+        table.add_row(
+            rank,
+            name,
+            rating,
+            matches_played,
+        )
+
+    console.print(table)
+    if not around:
+        console.print(f"\n[dim]Showing {len(rankings)} of {total_after_filter} teams. Use --limit or --around.[/dim]")

fcode/commands/login.py

@@ -0,0 +1,135 @@
+"""fcode login — authenticate via browser-based flow."""
+
+import json
+import secrets
+import urllib.request
+import webbrowser
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from urllib.parse import urlparse, parse_qs
+
+import click
+from rich.console import Console
+
+from fcode.auth import get_api_url, save_credentials, load_credentials
+
+console = Console()
+
+
+class _CallbackHandler(BaseHTTPRequestHandler):
+    """Handles the localhost callback from the browser."""
+
+    code: str | None = None
+    state: str | None = None
+
+    def do_GET(self):
+        parsed = urlparse(self.path)
+        params = parse_qs(parsed.query)
+
+        self.server._code = params.get("code", [None])[0]
+        self.server._state = params.get("state", [None])[0]
+
+        self.send_response(200)
+        self.send_header("Content-Type", "text/html")
+        self.end_headers()
+        self.wfile.write(
+            b"<html><body style='font-family:system-ui;display:flex;justify-content:center;"
+            b"align-items:center;height:100vh;margin:0;background:#0a0a0a;color:#fafafa'>"
+            b"<div style='text-align:center'>"
+            b"<h2>Authorized</h2>"
+            b"<p>You can close this tab and return to your terminal.</p>"
+            b"</div></body></html>"
+        )
+
+    def log_message(self, format, *args):
+        pass  # Suppress request logging
+
+
+@click.command()
+def login():
+    """Authenticate with the Florent Code League platform."""
+    existing = load_credentials()
+    if existing:
+        user = existing.get("user", {})
+        console.print(
+            f"Already logged in as [bold]{user.get('name', '?')}[/bold] ({user.get('email', '?')})"
+        )
+        if not click.confirm("Log in again?", default=False):
+            return
+
+    api_url = get_api_url()
+    state = secrets.token_urlsafe(32)
+
+    # Start a local server to receive the callback
+    server = HTTPServer(("127.0.0.1", 0), _CallbackHandler)
+    port = server.server_address[1]
+
+    auth_url = f"{api_url}/cli/auth?port={port}&state={state}"
+
+    console.print(f"Opening browser to authenticate...")
+    console.print(f"If the browser doesn't open, visit: [link={auth_url}]{auth_url}[/link]")
+
+    webbrowser.open(auth_url)
+
+    # Wait for the callback (with timeout)
+    server.timeout = 120
+    server._code = None
+    server._state = None
+
+    console.print("Waiting for authorization...", style="dim")
+    while server._code is None:
+        server.handle_request()
+        if server._code is None and server._state is None:
+            # Timeout or unexpected request
+            break
+
+    server.server_close()
+
+    if not server._code:
+        console.print("[red]Authorization timed out or was cancelled.[/red]")
+        raise SystemExit(1)
+
+    if server._state != state:
+        console.print("[red]State mismatch — possible CSRF attack. Aborting.[/red]")
+        raise SystemExit(1)
+
+    # Exchange the code for a session token
+    console.print("Exchanging authorization code...", style="dim")
+    try:
+        payload = json.dumps({"code": server._code}).encode()
+        req = urllib.request.Request(
+            f"{api_url}/api/cli/exchange",
+            data=payload,
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            data = json.loads(resp.read())
+    except urllib.error.HTTPError as e:
+        try:
+            body = json.loads(e.read())
+            msg = body.get("error", str(e))
+        except Exception:
+            msg = str(e)
+        console.print(f"[red]Authentication failed: {msg}[/red]")
+        raise SystemExit(1)
+    except Exception as e:
+        console.print(f"[red]Authentication failed: {e}[/red]")
+        raise SystemExit(1)
+
+    token = data.get("token")
+    if not token:
+        console.print("[red]Invalid response from server.[/red]")
+        raise SystemExit(1)
+
+    save_credentials(
+        token=token,
+        expires_at=data.get("expires_at", ""),
+        user=data.get("user", {}),
+        team=data.get("team"),
+    )
+
+    user = data.get("user", {})
+    team = data.get("team")
+    console.print(f"\n[green]Logged in as [bold]{user.get('name', '?')}[/bold][/green] ({user.get('email', '?')})")
+    if team:
+        console.print(f"  Team: [bold]{team.get('name', '?')}[/bold]")

fcode/commands/logout.py

@@ -0,0 +1,21 @@
+"""fcode logout — clear stored credentials."""
+
+import click
+from rich.console import Console
+
+from fcode.auth import clear_credentials, load_credentials
+
+console = Console()
+
+
+@click.command()
+def logout():
+    """Clear stored authentication credentials."""
+    existing = load_credentials()
+    if not existing:
+        console.print("Not currently logged in.")
+        return
+
+    clear_credentials()
+    user = existing.get("user", {})
+    console.print(f"Logged out (was [bold]{user.get('name', '?')}[/bold]).")

fcode/commands/map_editor.py

@@ -0,0 +1,91 @@
+"""fcode map-editor — open map editor locally or on platform."""
+
+import click
+from rich.console import Console
+
+console = Console()
+
+
+@click.command("map-editor")
+@click.option("--platform", "use_platform", is_flag=True, help="Open map editor on platform instead of locally")
+def map_editor(use_platform: bool):
+    """Open the map editor.
+
+    \b
+    Examples:
+      fcode map-editor              # Open map editor locally
+      fcode map-editor --platform   # Open on platform
+    """
+    if use_platform:
+        _open_platform()
+    else:
+        _serve_local()
+
+
+def _open_platform() -> None:
+    """Open the platform map editor page in the user's browser."""
+    import webbrowser
+    from fcode.auth import get_api_url
+
+    base_url = get_api_url()
+    url = f"{base_url}/map-editor"
+
+    console.print(f"Opening map editor: [link={url}]{url}[/link]")
+    webbrowser.open(url)
+
+
+def _serve_local() -> None:
+    """Serve the map editor locally."""
+    import http.server
+    import threading
+    import webbrowser
+    from pathlib import Path
+
+    mono_dist = Path(__file__).parent.parent.parent.parent.parent / "visualiser" / "dist"
+    bundled_dist = Path(__file__).parent.parent / "data" / "visualiser"
+
+    if (mono_dist / "map-editor.html").is_file():
+        dist_path = str(mono_dist.resolve())
+    elif (bundled_dist / "map-editor.html").is_file():
+        dist_path = str(bundled_dist.resolve())
+    else:
+        console.print(
+            "[red]Map editor not found. "
+            "Try reinstalling fcode or use --platform to open on the platform.[/red]"
+        )
+        raise SystemExit(1)
+
+    # Ensure correct MIME types on Windows (registry may map .js to text/plain)
+    import mimetypes
+
+    mimetypes.add_type("application/javascript", ".js")
+    mimetypes.add_type("application/javascript", ".mjs")
+    mimetypes.add_type("application/wasm", ".wasm")
+    mimetypes.add_type("text/css", ".css")
+
+    class EditorHandler(http.server.SimpleHTTPRequestHandler):
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, directory=dist_path, **kwargs)
+
+        def do_GET(self):
+            if self.path == "/" or self.path.startswith("/?"):
+                self.path = "/map-editor.html"
+            super().do_GET()
+
+        def log_message(self, format, *args):
+            pass
+
+    server = http.server.HTTPServer(("127.0.0.1", 0), EditorHandler)
+    port = server.server_address[1]
+
+    url = f"http://127.0.0.1:{port}/"
+    console.print(f"Serving map editor at [link={url}]{url}[/link]")
+    console.print("[dim]Press Ctrl+C to stop[/dim]")
+
+    threading.Timer(0.5, lambda: webbrowser.open(url)).start()
+
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        console.print("\n[dim]Stopped.[/dim]")
+        server.shutdown()