study-sync 1.0.4__tar.gz → 1.0.8__tar.gz

{study_sync-1.0.4 → study_sync-1.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: study_sync
-Version: 1.0.4
+Version: 1.0.8
 Summary: Offline-first, distributed workspace synchronisation CLI for developers.
 Author-email: Malatesh <malateshbsunkad03@gmail.com>, Adinath <adinarayan.is23@bmsce.ac.in>
 License: MIT

{study_sync-1.0.4 → study_sync-1.0.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "study_sync"
-version = "1.0.4"
+version = "1.0.8"
 description = "Offline-first, distributed workspace synchronisation CLI for developers."
 license = { text = "MIT" }
 requires-python = ">=3.10"

{study_sync-1.0.4 → study_sync-1.0.8}/study_sync.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: study_sync
-Version: 1.0.4
+Version: 1.0.8
 Summary: Offline-first, distributed workspace synchronisation CLI for developers.
 Author-email: Malatesh <malateshbsunkad03@gmail.com>, Adinath <adinarayan.is23@bmsce.ac.in>
 License: MIT

study_sync-1.0.8/studysync/sync_engine.py

@@ -0,0 +1,670 @@
+"""
+sync_engine.py — Core networking and sync logic for StudySync CLI.
+
+Two-phase upload
+----------------
+1. POST /upload-request  → {presigned_put_url, pending_upload_id}
+2. PUT presigned_put_url (raw bytes)
+3. POST /commit-upload   → updated file record
+
+Optimistic concurrency control
+-------------------------------
+Every push includes base_version.  If that doesn't match the server's
+latest_version the server returns HTTP 409.  The client must pull first.
+
+Alias resolution
+-----------------
+Users can join with a short workspace alias (name) instead of a raw UUID.
+SyncEngine.resolve_alias() calls GET /alias/{alias} on the backend, which
+returns the workspace's access_token.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import sys
+from pathlib import Path
+from typing import Any
+
+import requests
+from requests import HTTPError, Session
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import (
+    BarColumn,
+    DownloadColumn,
+    Progress,
+    TextColumn,
+    TimeRemainingColumn,
+    TransferSpeedColumn,
+)
+from rich.table import Table
+
+from .constants import PRODUCTION_SERVER_URL
+from .local_state import (
+    all_local_files,
+    ensure_dirs,
+    load_config,
+    load_manifest,
+    local_file_path,
+    save_manifest,
+    sha256_file,
+    update_manifest_entry,
+    workspace_root,
+    WORKSPACES_DIR,
+)
+
+console = Console()
+
+# ---------------------------------------------------------------------------
+# Progress-aware file reader
+# ---------------------------------------------------------------------------
+
+class _ProgressReader:
+    """Wrap a file so requests streams it while updating a Rich progress bar."""
+
+    def __init__(self, path: Path, task_id: Any, progress: Progress) -> None:
+        self._fh = open(path, "rb")
+        self._task_id = task_id
+        self._progress = progress
+        self._size = path.stat().st_size
+
+    def read(self, size: int = -1) -> bytes:
+        chunk = self._fh.read(size)
+        if chunk:
+            self._progress.update(self._task_id, advance=len(chunk))
+        return chunk
+
+    def __len__(self) -> int:
+        return self._size
+
+    def close(self) -> None:
+        self._fh.close()
+
+    def __enter__(self) -> "_ProgressReader":
+        return self
+
+    def __exit__(self, *_: Any) -> None:
+        self.close()
+
+
+# ---------------------------------------------------------------------------
+# SyncEngine
+# ---------------------------------------------------------------------------
+
+class SyncEngine:
+    """Handles all communication with the StudySync backend."""
+
+    def __init__(self, server_url: str | None = None) -> None:
+        ensure_dirs()
+        config = load_config()
+        raw_url = server_url or config.get("server_url", PRODUCTION_SERVER_URL)
+        self.base_url: str = raw_url.rstrip("/")
+        self.workspace_id: str = config.get("workspace_id", "")
+        self.workspace_name: str = config.get("workspace_name", "")
+        self.token: str = config.get("workspace_token", "")
+
+        self.session: Session = requests.Session()
+        if self.token:
+            self.session.headers["Authorization"] = f"Bearer {self.token}"
+        self.session.headers["User-Agent"] = "studysync-cli/1.0"
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _raise_for_status(self, resp: requests.Response) -> None:
+        """Raise HTTPError with the backend's JSON detail if present."""
+        if resp.ok:
+            return
+        try:
+            detail = resp.json().get("detail", resp.text)
+        except Exception:
+            detail = resp.text
+        raise HTTPError(
+            f"HTTP {resp.status_code}: {detail}",
+            response=resp,
+        )
+
+    def _get(self, url: str, **kwargs: Any) -> requests.Response:
+        """GET with automatic cold-start retry."""
+        return self._request_with_retry("GET", url, **kwargs)
+
+    def _post(self, url: str, **kwargs: Any) -> requests.Response:
+        """POST with automatic cold-start retry."""
+        return self._request_with_retry("POST", url, **kwargs)
+
+    def _put(self, url: str, **kwargs: Any) -> requests.Response:
+        """PUT with automatic cold-start retry (no cold-start retry for binary uploads)."""
+        kwargs.setdefault("timeout", 90)
+        return self.session.put(url, **kwargs)
+
+    def _request_with_retry(self, method: str, url: str, **kwargs: Any) -> requests.Response:
+        """Send a request; on ReadTimeout show a wakeup message and retry once."""
+        kwargs.setdefault("timeout", 90)
+        try:
+            return self.session.request(method, url, **kwargs)
+        except requests.ReadTimeout:
+            console.print(
+                "[yellow]⏳ Server is waking up (Render cold start) — retrying, please wait…[/yellow]"
+            )
+            kwargs["timeout"] = 120
+            return self.session.request(method, url, **kwargs)
+
+    def _require_workspace(self) -> None:
+        """Abort with a friendly message if no workspace is configured."""
+        if not self.workspace_id or not self.token:
+            console.print(
+                Panel(
+                    "No workspace is configured.\n\n"
+                    "Create one:  [cyan]study workspace create <name>[/cyan]\n"
+                    "Or join one: [cyan]study join <token-or-alias>[/cyan]",
+                    title="[bold red]✗ Not configured[/bold red]",
+                    border_style="red",
+                    padding=(1, 2),
+                )
+            )
+            sys.exit(1)
+
+    # ------------------------------------------------------------------
+    # Workspace management
+    # ------------------------------------------------------------------
+
+    def create_workspace(self, name: str) -> dict[str, Any]:
+        """POST /workspaces — create a new workspace; returns {workspace_id, access_token, name}."""
+        resp = self._post(
+            f"{self.base_url}/workspaces",
+            json={"name": name},
+        )
+        self._raise_for_status(resp)
+        data = resp.json()
+        return {
+            "workspace_id": data["workspace_id"],
+            "access_token": data["access_token"],
+            "name": data["name"],
+        }
+
+    def join_workspace(self, token: str) -> dict[str, Any]:
+        """GET /workspaces/{token} — validate token; returns {workspace_id, name}."""
+        resp = self._get(
+            f"{self.base_url}/workspaces/{token}",
+        )
+        self._raise_for_status(resp)
+        data = resp.json()
+        return {
+            "workspace_id": data["workspace_id"],
+            "name": data["name"],
+        }
+
+    def resolve_input(self, token_or_alias: str) -> dict:
+        """
+        GET /resolve/{input} — resolve a token or alias to workspace info.
+
+        The backend checks its Aliases table first.  If the input is not a
+        known alias it tries to interpret it as a raw UUID access_token.
+
+        Returns
+        -------
+        dict
+            Keys: ``resolved_from_alias`` (bool), ``alias`` (str | None),
+            ``workspace_id``, ``name``, ``access_token``.
+
+        Raises
+        ------
+        SystemExit
+            Prints a red error panel and exits 1 on HTTP 404 or connection
+            failure.
+        """
+        try:
+            resp = self._get(
+                f"{self.base_url}/resolve/{token_or_alias}",
+            )
+            self._raise_for_status(resp)
+            return resp.json()
+        except HTTPError as exc:
+            code = exc.response.status_code if exc.response is not None else "?"
+            try:
+                detail = exc.response.json().get("detail", str(exc))
+            except Exception:
+                detail = str(exc)
+            console.print(
+                Panel(
+                    f"{detail}",
+                    title=f"[bold red]✗ Could not resolve '{token_or_alias}'[/bold red]",
+                    border_style="red",
+                    padding=(1, 2),
+                )
+            )
+            sys.exit(1)
+        except requests.ConnectionError:
+            console.print(
+                Panel(
+                    f"Could not reach [cyan]{self.base_url}[/cyan].\n"
+                    "Check your network connection or --server URL.",
+                    title="[bold red]✗ Connection error[/bold red]",
+                    border_style="red",
+                    padding=(1, 2),
+                )
+            )
+            sys.exit(1)
+
+    # ------------------------------------------------------------------
+    # Pull
+    # ------------------------------------------------------------------
+
+    # ------------------------------------------------------------------
+    # Pull helpers
+    # ------------------------------------------------------------------
+
+    # ===========================================================================
+    # pull  — server is always source of truth
+    # ===========================================================================
+
+    def pull(self) -> None:
+        """
+        Download every file from the remote workspace that is missing or
+        out-of-date locally.
+
+        "Missing" means either:
+          - the file is not in the local manifest at all (first pull after join), OR
+          - the file IS in the manifest but the physical file is gone from disk.
+
+        "Out-of-date" means:
+          - the server has a higher version number.
+
+        Both conditions force a download so the local directory always matches
+        the server without any user intervention.
+        """
+        self._require_workspace()
+
+        # ── 1. Fetch server state ─────────────────────────────────────────
+        with console.status("[blue]Fetching workspace state…[/blue]", spinner="dots"):
+            try:
+                resp = self._get(
+                    f"{self.base_url}/sync/state/{self.token}",
+                )
+                self._raise_for_status(resp)
+            except (HTTPError, requests.ConnectionError) as exc:
+                console.print(
+                    Panel(str(exc),
+                          title="[bold red]✗ Pull failed[/bold red]",
+                          border_style="red", padding=(1, 2))
+                )
+                sys.exit(1)
+
+        remote_files: list[dict] = resp.json().get("files", [])
+        if not remote_files:
+            console.print("[dim]Remote workspace is empty — nothing to pull.[/dim]")
+            return
+
+        # ── 2. Decide what to download ────────────────────────────────────
+        manifest = load_manifest()
+        cwd = Path(os.getcwd())
+
+        to_download: list[dict] = []
+        for rf in remote_files:
+            fp              = rf["file_path"]
+            remote_ver      = rf["latest_version"]
+            local_ver       = manifest.get(fp, {}).get("version", 0)
+            file_on_disk    = (cwd / fp).exists()
+
+            if not file_on_disk or local_ver < remote_ver:
+                to_download.append(rf)
+
+        if not to_download:
+            console.print(
+                Panel(
+                    f"All {len(remote_files)} file(s) are up to date.",
+                    title="[bold green]✓ Already in sync[/bold green]",
+                    border_style="green", padding=(0, 2),
+                )
+            )
+            return
+
+        # ── 3. Download each file ─────────────────────────────────────────
+        updated: list[str] = []
+        errors:  list[str] = []
+
+        progress = Progress(
+            TextColumn("[bold blue]{task.fields[filename]}"),
+            BarColumn(), DownloadColumn(),
+            TransferSpeedColumn(), TimeRemainingColumn(),
+            console=console,
+        )
+
+        with progress:
+            for rf in to_download:
+                fp       = rf["file_path"]
+                version  = rf["latest_version"]
+                checksum = rf.get("latest_checksum") or ""
+                size     = rf.get("size_bytes") or 0
+
+                task_id = progress.add_task(
+                    "dl", filename=fp,
+                    total=size if size > 0 else None,
+                )
+
+                # Request presigned GET URL
+                try:
+                    dl = self._get(
+                        f"{self.base_url}/sync/download-request",
+                        params={"workspace_token": self.token, "file_path": fp},
+                    )
+                    self._raise_for_status(dl)
+                except (HTTPError, requests.ConnectionError) as exc:
+                    errors.append(f"{fp}: {exc}")
+                    progress.update(task_id, visible=False)
+                    continue
+
+                presigned_url = dl.json()["presigned_url"]
+
+                # Stream to vault
+                vault_path = local_file_path(self.workspace_name, fp)
+                vault_path.parent.mkdir(parents=True, exist_ok=True)
+                try:
+                    with requests.get(presigned_url, stream=True, timeout=120) as r:
+                        self._raise_for_status(r)
+                        with open(vault_path, "wb") as fh:
+                            for chunk in r.iter_content(65_536):
+                                fh.write(chunk)
+                                progress.update(task_id, advance=len(chunk))
+                except Exception as exc:
+                    errors.append(f"{fp}: {exc}")
+                    progress.update(task_id, visible=False)
+                    continue
+
+                # Verify checksum
+                if checksum and sha256_file(vault_path) != checksum:
+                    vault_path.unlink(missing_ok=True)
+                    errors.append(f"{fp}: checksum mismatch — file discarded, try again")
+                    progress.update(task_id, visible=False)
+                    continue
+
+                # Write to working directory
+                dest = cwd / fp
+                dest.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(vault_path, dest)
+
+                update_manifest_entry(fp, version, checksum)
+                updated.append(fp)
+
+        # ── 4. Report ─────────────────────────────────────────────────────
+        if updated:
+            console.print(
+                Panel(
+                    "\n".join(f"  [green]✓[/green] {f}" for f in updated),
+                    title=f"[bold green]✓ Pulled {len(updated)} file(s)[/bold green]",
+                    border_style="green", padding=(1, 2),
+                )
+            )
+        if errors:
+            console.print(
+                Panel(
+                    "\n".join(f"  [red]✗[/red] {e}" for e in errors),
+                    title="[bold red]✗ Some files failed[/bold red]",
+                    border_style="red", padding=(1, 2),
+                )
+            )
+            sys.exit(1)
+
+    # ===========================================================================
+    # push  — two-phase upload with OCC conflict detection
+    # ===========================================================================
+
+    def push(self, file_path: str) -> None:
+        """
+        Upload a local file to the remote workspace.
+
+        Uses Optimistic Concurrency Control (OCC): the client sends its
+        `base_version` (last known server version).  If the server's current
+        version is higher, it returns HTTP 409 — the user must pull first.
+        """
+        self._require_workspace()
+
+        local_path = Path(file_path)
+        if not local_path.exists():
+            console.print(
+                Panel(f"[bold]{file_path}[/bold] does not exist.",
+                      title="[bold red]✗ File not found[/bold red]",
+                      border_style="red", padding=(1, 2))
+            )
+            sys.exit(1)
+
+        with console.status(f"[blue]Hashing [bold]{file_path}[/bold]…[/blue]", spinner="dots"):
+            checksum = sha256_file(local_path)
+            size     = local_path.stat().st_size
+
+        manifest     = load_manifest()
+        base_version = manifest.get(file_path, {}).get("version", 0)
+
+        # ── Step 1: request upload slot ───────────────────────────────────
+        with console.status("[blue]Requesting upload slot…[/blue]", spinner="dots"):
+            try:
+                req = self._post(
+                    f"{self.base_url}/sync/upload-request",
+                    json={
+                        "workspace_token": self.token,
+                        "file_path":       file_path,
+                        "checksum":        checksum,
+                        "size_bytes":      size,
+                        "base_version":    base_version,
+                    },
+                )
+                self._raise_for_status(req)
+
+            except HTTPError as exc:
+                if exc.response is not None and exc.response.status_code == 409:
+                    # ── OCC conflict: server has a newer version ──────────
+                    try:
+                        remote_ver = exc.response.json().get("detail", "")
+                    except Exception:
+                        remote_ver = ""
+                    console.print(
+                        Panel(
+                            f"[bold]{file_path}[/bold] has been updated on the server "
+                            f"since your last pull.\n\n"
+                            f"Your local base version : [cyan]{base_version}[/cyan]\n"
+                            f"Run [cyan]study pull[/cyan] to get the latest version, "
+                            f"then push again.",
+                            title="[bold red]✗ Conflict — pull required[/bold red]",
+                            border_style="red", padding=(1, 2),
+                        )
+                    )
+                else:
+                    console.print(
+                        Panel(str(exc),
+                              title="[bold red]✗ Upload request failed[/bold red]",
+                              border_style="red", padding=(1, 2))
+                    )
+                sys.exit(1)
+            except requests.ConnectionError as exc:
+                console.print(
+                    Panel(str(exc),
+                          title="[bold red]✗ Connection error[/bold red]",
+                          border_style="red", padding=(1, 2))
+                )
+                sys.exit(1)
+
+        data         = req.json()
+        presigned_url = data["presigned_url"]
+        upload_id    = data["upload_id"]
+        new_version  = data["new_version"]
+
+        # ── Step 2: PUT bytes to mock-S3 ─────────────────────────────────
+        progress = Progress(
+            TextColumn("[bold blue]{task.fields[filename]}"),
+            BarColumn(), DownloadColumn(),
+            TransferSpeedColumn(), TimeRemainingColumn(),
+            console=console,
+        )
+        with progress:
+            task_id = progress.add_task("upload", filename=local_path.name, total=size)
+            with _ProgressReader(local_path, task_id, progress) as reader:
+                try:
+                    put = requests.put(
+                        presigned_url,
+                        data=reader,
+                        headers={"Content-Length": str(size)},
+                        timeout=300,
+                    )
+                    put.raise_for_status()
+                except Exception as exc:
+                    console.print(
+                        Panel(str(exc),
+                              title="[bold red]✗ Upload failed[/bold red]",
+                              border_style="red", padding=(1, 2))
+                    )
+                    sys.exit(1)
+
+        # ── Step 3: commit ────────────────────────────────────────────────
+        with console.status("[blue]Committing…[/blue]", spinner="dots"):
+            try:
+                commit = self._post(
+                    f"{self.base_url}/sync/commit-upload",
+                    json={"upload_id": upload_id},
+                )
+                self._raise_for_status(commit)
+            except (HTTPError, requests.ConnectionError) as exc:
+                console.print(
+                    Panel(str(exc),
+                          title="[bold red]✗ Commit failed[/bold red]",
+                          border_style="red", padding=(1, 2))
+                )
+                sys.exit(1)
+
+        # Update vault + manifest
+        vault_path = local_file_path(self.workspace_name, file_path)
+        vault_path.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(local_path, vault_path)
+        update_manifest_entry(file_path, new_version, checksum)
+
+        console.print(
+            Panel(
+                f"[bold]{file_path}[/bold]\n"
+                f"Version  [cyan]v{new_version}[/cyan]   "
+                f"SHA-256  [dim]{checksum[:16]}…[/dim]   "
+                f"Size  [dim]{size:,} B[/dim]",
+                title="[bold green]✓ Push complete[/bold green]",
+                border_style="green", padding=(1, 2),
+            )
+        )
+
+    # ===========================================================================
+    # status  — shows both local and server state
+    # ===========================================================================
+
+    def status(self) -> None:
+        """
+        Compare the remote workspace against local state and display a table.
+
+        Fetches the server's file list so that files pushed by other users
+        show up immediately — even before a pull.
+
+        Status values
+        -------------
+        SYNCED    on disk and matching the server version
+        MODIFIED  on disk but changed since the last push/pull
+        NOT PULLED exists on server, not yet downloaded
+        MISSING   in manifest but physically deleted from disk
+        LOCAL     on disk but never pushed (untracked)
+        """
+        self._require_workspace()
+
+        # Fetch server state so we can show files pushed by other users
+        with console.status("[blue]Fetching server state…[/blue]", spinner="dots"):
+            try:
+                resp = self._get(
+                    f"{self.base_url}/sync/state/{self.token}",
+                )
+                self._raise_for_status(resp)
+                remote_files = {
+                    f["file_path"]: f
+                    for f in resp.json().get("files", [])
+                }
+            except (HTTPError, requests.ConnectionError):
+                remote_files = {}
+                console.print(
+                    "[yellow]⚠ Could not reach server — showing local state only.[/yellow]"
+                )
+
+        manifest = load_manifest()
+        cwd      = Path(os.getcwd())
+
+        # Collect every file path we know about from any source
+        all_paths: set[str] = set()
+        all_paths.update(remote_files.keys())
+        all_paths.update(manifest.keys())
+        # Add untracked files in cwd (skip hidden directories)
+        for p in cwd.rglob("*"):
+            if p.is_file() and not any(part.startswith(".") for part in p.parts):
+                all_paths.add(str(p.relative_to(cwd)).replace("\\", "/"))
+
+        if not all_paths:
+            console.print(
+                "[dim]No files yet.  Run [cyan]study push <file>[/cyan] to get started.[/dim]"
+            )
+            return
+
+        table = Table(
+            title=f"Workspace: [bold]{self.workspace_name}[/bold]",
+            show_lines=False, show_header=True,
+        )
+        table.add_column("File",         style="bold", no_wrap=True)
+        table.add_column("Status",       justify="center")
+        table.add_column("Local ver",    justify="right", style="dim")
+        table.add_column("Server ver",   justify="right", style="dim")
+
+        for fp in sorted(all_paths):
+            local_entry  = manifest.get(fp, {})
+            local_ver    = local_entry.get("version", 0)
+            local_cksum  = local_entry.get("checksum", "")
+            remote_info  = remote_files.get(fp)
+            remote_ver   = remote_info["latest_version"] if remote_info else None
+            file_on_disk = (cwd / fp).exists()
+
+            if remote_info and not file_on_disk and not local_entry:
+                # Other user pushed this; we've never seen it
+                status_cell  = "[cyan]NOT PULLED[/cyan]"
+                l_ver_str    = "—"
+                r_ver_str    = f"v{remote_ver}"
+
+            elif remote_info and not file_on_disk and local_entry:
+                # Was here, now gone from disk
+                status_cell  = "[red]MISSING[/red]"
+                l_ver_str    = f"v{local_ver}"
+                r_ver_str    = f"v{remote_ver}"
+
+            elif remote_info and file_on_disk:
+                disk_cksum = sha256_file(cwd / fp)
+                if disk_cksum == remote_info.get("latest_checksum", ""):
+                    status_cell = "[green]SYNCED[/green]"
+                elif disk_cksum == local_cksum:
+                    # Disk matches our last push but server moved ahead
+                    status_cell = "[cyan]NOT PULLED[/cyan]"
+                else:
+                    status_cell = "[yellow]MODIFIED[/yellow]"
+                l_ver_str = f"v{local_ver}" if local_ver else "—"
+                r_ver_str = f"v{remote_ver}"
+
+            elif not remote_info and file_on_disk:
+                # Local file not known to server
+                status_cell  = "[dim]LOCAL[/dim]"
+                l_ver_str    = "—"
+                r_ver_str    = "—"
+
+            else:
+                continue  # ghost entry, skip
+
+            table.add_row(fp, status_cell, l_ver_str, r_ver_str)
+
+        console.print(table)
+        console.print(
+            "[dim]"
+            "[green]SYNCED[/green]=up to date  "
+            "[yellow]MODIFIED[/yellow]=local changes  "
+            "[cyan]NOT PULLED[/cyan]=pull to get  "
+            "[red]MISSING[/red]=deleted locally  "
+            "[dim]LOCAL[/dim]=not yet pushed"
+            "[/dim]"
+        )

study_sync-1.0.4/studysync/sync_engine.py

@@ -1,587 +0,0 @@
-"""
-sync_engine.py — Core networking and sync logic for StudySync CLI.
-
-Two-phase upload
-----------------
-1. POST /upload-request  → {presigned_put_url, pending_upload_id}
-2. PUT presigned_put_url (raw bytes)
-3. POST /commit-upload   → updated file record
-
-Optimistic concurrency control
--------------------------------
-Every push includes base_version.  If that doesn't match the server's
-latest_version the server returns HTTP 409.  The client must pull first.
-
-Alias resolution
------------------
-Users can join with a short workspace alias (name) instead of a raw UUID.
-SyncEngine.resolve_alias() calls GET /alias/{alias} on the backend, which
-returns the workspace's access_token.
-"""
-
-from __future__ import annotations
-
-import os
-import shutil
-import sys
-from pathlib import Path
-from typing import Any
-
-import requests
-from requests import HTTPError, Session
-from rich.console import Console
-from rich.panel import Panel
-from rich.progress import (
-    BarColumn,
-    DownloadColumn,
-    Progress,
-    TextColumn,
-    TimeRemainingColumn,
-    TransferSpeedColumn,
-)
-from rich.table import Table
-
-from .constants import PRODUCTION_SERVER_URL
-from .local_state import (
-    all_local_files,
-    ensure_dirs,
-    load_config,
-    load_manifest,
-    local_file_path,
-    save_manifest,
-    sha256_file,
-    update_manifest_entry,
-    workspace_root,
-    WORKSPACES_DIR,
-)
-
-console = Console()
-
-# ---------------------------------------------------------------------------
-# Progress-aware file reader
-# ---------------------------------------------------------------------------
-
-class _ProgressReader:
-    """Wrap a file so requests streams it while updating a Rich progress bar."""
-
-    def __init__(self, path: Path, task_id: Any, progress: Progress) -> None:
-        self._fh = open(path, "rb")
-        self._task_id = task_id
-        self._progress = progress
-        self._size = path.stat().st_size
-
-    def read(self, size: int = -1) -> bytes:
-        chunk = self._fh.read(size)
-        if chunk:
-            self._progress.update(self._task_id, advance=len(chunk))
-        return chunk
-
-    def __len__(self) -> int:
-        return self._size
-
-    def close(self) -> None:
-        self._fh.close()
-
-    def __enter__(self) -> "_ProgressReader":
-        return self
-
-    def __exit__(self, *_: Any) -> None:
-        self.close()
-
-
-# ---------------------------------------------------------------------------
-# SyncEngine
-# ---------------------------------------------------------------------------
-
-class SyncEngine:
-    """Handles all communication with the StudySync backend."""
-
-    def __init__(self, server_url: str | None = None) -> None:
-        ensure_dirs()
-        config = load_config()
-        raw_url = server_url or config.get("server_url", PRODUCTION_SERVER_URL)
-        self.base_url: str = raw_url.rstrip("/")
-        self.workspace_id: str = config.get("workspace_id", "")
-        self.workspace_name: str = config.get("workspace_name", "")
-        self.token: str = config.get("workspace_token", "")
-
-        self.session: Session = requests.Session()
-        if self.token:
-            self.session.headers["Authorization"] = f"Bearer {self.token}"
-        self.session.headers["User-Agent"] = "studysync-cli/1.0"
-
-    # ------------------------------------------------------------------
-    # Internal helpers
-    # ------------------------------------------------------------------
-
-    def _raise_for_status(self, resp: requests.Response) -> None:
-        """Raise HTTPError with the backend's JSON detail if present."""
-        if resp.ok:
-            return
-        try:
-            detail = resp.json().get("detail", resp.text)
-        except Exception:
-            detail = resp.text
-        raise HTTPError(
-            f"HTTP {resp.status_code}: {detail}",
-            response=resp,
-        )
-
-    def _require_workspace(self) -> None:
-        """Abort with a friendly message if no workspace is configured."""
-        if not self.workspace_id or not self.token:
-            console.print(
-                Panel(
-                    "No workspace is configured.\n\n"
-                    "Create one:  [cyan]study workspace create <name>[/cyan]\n"
-                    "Or join one: [cyan]study join <token-or-alias>[/cyan]",
-                    title="[bold red]✗ Not configured[/bold red]",
-                    border_style="red",
-                    padding=(1, 2),
-                )
-            )
-            sys.exit(1)
-
-    # ------------------------------------------------------------------
-    # Workspace management
-    # ------------------------------------------------------------------
-
-    def create_workspace(self, name: str) -> dict[str, Any]:
-        """POST /workspaces — create a new workspace; returns {workspace_id, access_token, name}."""
-        resp = self.session.post(
-            f"{self.base_url}/workspaces",
-            json={"name": name},
-            timeout=30,
-        )
-        self._raise_for_status(resp)
-        data = resp.json()
-        return {
-            "workspace_id": data["workspace_id"],
-            "access_token": data["access_token"],
-            "name": data["name"],
-        }
-
-    def join_workspace(self, token: str) -> dict[str, Any]:
-        """GET /workspaces/{token} — validate token; returns {workspace_id, name}."""
-        resp = self.session.get(
-            f"{self.base_url}/workspaces/{token}",
-            timeout=30,
-        )
-        self._raise_for_status(resp)
-        data = resp.json()
-        return {
-            "workspace_id": data["workspace_id"],
-            "name": data["name"],
-        }
-
-    def resolve_input(self, token_or_alias: str) -> dict:
-        """
-        GET /resolve/{input} — resolve a token or alias to workspace info.
-
-        The backend checks its Aliases table first.  If the input is not a
-        known alias it tries to interpret it as a raw UUID access_token.
-
-        Returns
-        -------
-        dict
-            Keys: ``resolved_from_alias`` (bool), ``alias`` (str | None),
-            ``workspace_id``, ``name``, ``access_token``.
-
-        Raises
-        ------
-        SystemExit
-            Prints a red error panel and exits 1 on HTTP 404 or connection
-            failure.
-        """
-        try:
-            resp = self.session.get(
-                f"{self.base_url}/resolve/{token_or_alias}",
-                timeout=15,
-            )
-            self._raise_for_status(resp)
-            return resp.json()
-        except HTTPError as exc:
-            code = exc.response.status_code if exc.response is not None else "?"
-            try:
-                detail = exc.response.json().get("detail", str(exc))
-            except Exception:
-                detail = str(exc)
-            console.print(
-                Panel(
-                    f"{detail}",
-                    title=f"[bold red]✗ Could not resolve '{token_or_alias}'[/bold red]",
-                    border_style="red",
-                    padding=(1, 2),
-                )
-            )
-            sys.exit(1)
-        except requests.ConnectionError:
-            console.print(
-                Panel(
-                    f"Could not reach [cyan]{self.base_url}[/cyan].\n"
-                    "Check your network connection or --server URL.",
-                    title="[bold red]✗ Connection error[/bold red]",
-                    border_style="red",
-                    padding=(1, 2),
-                )
-            )
-            sys.exit(1)
-
-    # ------------------------------------------------------------------
-    # Pull
-    # ------------------------------------------------------------------
-
-    def pull(self) -> None:
-        """Download all new/changed files from the remote workspace."""
-        self._require_workspace()
-
-        # 1. Fetch remote state
-        with console.status("[blue]Fetching remote file list…[/blue]", spinner="dots"):
-            try:
-                resp = self.session.get(
-                    f"{self.base_url}/workspaces/{self.token}/state",
-                    timeout=30,
-                )
-                self._raise_for_status(resp)
-            except (HTTPError, requests.ConnectionError) as exc:
-                console.print(
-                    Panel(
-                        str(exc),
-                        title="[bold red]✗ Pull failed[/bold red]",
-                        border_style="red",
-                        padding=(1, 2),
-                    )
-                )
-                sys.exit(1)
-
-        remote_files: list[dict] = resp.json().get("files", [])
-        manifest = load_manifest()
-
-        if not remote_files:
-            console.print("[dim]No files in remote workspace.[/dim]")
-            return
-
-        # 2. Determine what to download
-        to_download = []
-        for rf in remote_files:
-            fp = rf["file_path"]
-            local_entry = manifest.get(fp, {})
-            if local_entry.get("version", -1) < rf["latest_version"]:
-                to_download.append(rf)
-
-        if not to_download:
-            console.print(
-                Panel(
-                    "Everything is up to date — no files to download.",
-                    title="[bold green]✓ Already in sync[/bold green]",
-                    border_style="green",
-                    padding=(0, 2),
-                )
-            )
-            return
-
-        # 3. Download each file with a progress bar
-        cwd = Path(os.getcwd())
-        updated: list[str] = []
-        errors: list[str] = []
-
-        progress = Progress(
-            TextColumn("[bold blue]{task.fields[filename]}"),
-            BarColumn(),
-            DownloadColumn(),
-            TransferSpeedColumn(),
-            TimeRemainingColumn(),
-            console=console,
-        )
-
-        with progress:
-            for rf in to_download:
-                fp: str = rf["file_path"]
-                version: int = rf["latest_version"]
-                checksum: str = rf["latest_checksum"]
-                size: int = rf.get("size_bytes", 0)
-
-                task_id = progress.add_task(
-                    "download",
-                    filename=fp,
-                    total=size if size > 0 else None,
-                )
-
-                # Request a presigned GET URL
-                try:
-                    dl_resp = self.session.post(
-                        f"{self.base_url}/download-request",
-                        json={"file_path": fp, "workspace_id": self.workspace_id},
-                        headers={"Authorization": f"Bearer {self.token}"},
-                        timeout=30,
-                    )
-                    self._raise_for_status(dl_resp)
-                except (HTTPError, requests.ConnectionError) as exc:
-                    errors.append(f"{fp}: {exc}")
-                    progress.update(task_id, visible=False)
-                    continue
-
-                presigned_get = dl_resp.json()["presigned_get_url"]
-
-                # Stream the file to the vault
-                vault_path = local_file_path(self.workspace_name, fp)
-                vault_path.parent.mkdir(parents=True, exist_ok=True)
-
-                try:
-                    with self.session.get(presigned_get, stream=True, timeout=120) as dr:
-                        self._raise_for_status(dr)
-                        with open(vault_path, "wb") as out:
-                            for chunk in dr.iter_content(chunk_size=65_536):
-                                out.write(chunk)
-                                progress.update(task_id, advance=len(chunk))
-                except Exception as exc:
-                    errors.append(f"{fp}: {exc}")
-                    progress.update(task_id, visible=False)
-                    continue
-
-                # Verify SHA-256
-                actual = sha256_file(vault_path)
-                if actual != checksum:
-                    errors.append(
-                        f"{fp}: checksum mismatch "
-                        f"(expected {checksum[:8]}…, got {actual[:8]}…)"
-                    )
-                    continue
-
-                # Checkout to cwd
-                checkout_dest = cwd / fp
-                checkout_dest.parent.mkdir(parents=True, exist_ok=True)
-                shutil.copy2(vault_path, checkout_dest)
-
-                update_manifest_entry(fp, version, checksum)
-                updated.append(fp)
-
-        # 4. Report
-        if updated:
-            file_list = "\n".join(f"  [green]✓[/green] {f}" for f in updated)
-            console.print(
-                Panel(
-                    file_list,
-                    title=f"[bold green]✓ Pulled {len(updated)} file(s)[/bold green]",
-                    border_style="green",
-                    padding=(1, 2),
-                )
-            )
-        if errors:
-            err_list = "\n".join(f"  [red]✗[/red] {e}" for e in errors)
-            console.print(
-                Panel(
-                    err_list,
-                    title="[bold red]✗ Some files failed[/bold red]",
-                    border_style="red",
-                    padding=(1, 2),
-                )
-            )
-            sys.exit(1)
-
-    # ------------------------------------------------------------------
-    # Push
-    # ------------------------------------------------------------------
-
-    def push(self, file_path: str) -> None:
-        """Upload *file_path* to the remote workspace."""
-        self._require_workspace()
-
-        local_path = Path(file_path)
-        if not local_path.exists():
-            console.print(
-                Panel(
-                    f"[bold]{file_path}[/bold] does not exist.",
-                    title="[bold red]✗ File not found[/bold red]",
-                    border_style="red",
-                    padding=(1, 2),
-                )
-            )
-            sys.exit(1)
-
-        with console.status(f"[blue]Hashing [bold]{file_path}[/bold]…[/blue]", spinner="dots"):
-            checksum = sha256_file(local_path)
-            size = local_path.stat().st_size
-
-        manifest = load_manifest()
-        base_version = manifest.get(file_path, {}).get("version", 0)
-
-        # Step 1 — upload-request
-        with console.status("[blue]Requesting upload slot…[/blue]", spinner="dots"):
-            try:
-                req_resp = self.session.post(
-                    f"{self.base_url}/upload-request",
-                    json={
-                        "file_path": file_path,
-                        "workspace_id": self.workspace_id,
-                        "checksum": checksum,
-                        "size_bytes": size,
-                        "base_version": base_version,
-                    },
-                    headers={"Authorization": f"Bearer {self.token}"},
-                    timeout=30,
-                )
-                self._raise_for_status(req_resp)
-            except HTTPError as exc:
-                if exc.response is not None and exc.response.status_code == 409:
-                    console.print(
-                        Panel(
-                            f"[bold]{file_path}[/bold] was modified on the server since your "
-                            f"last pull (local base version: {base_version}).\n\n"
-                            "Run [cyan]study pull[/cyan] to sync, then push again.",
-                            title="[bold red]✗ Conflict (HTTP 409)[/bold red]",
-                            border_style="red",
-                            padding=(1, 2),
-                        )
-                    )
-                else:
-                    console.print(
-                        Panel(
-                            str(exc),
-                            title="[bold red]✗ Upload request failed[/bold red]",
-                            border_style="red",
-                            padding=(1, 2),
-                        )
-                    )
-                sys.exit(1)
-            except requests.ConnectionError as exc:
-                console.print(
-                    Panel(
-                        str(exc),
-                        title="[bold red]✗ Connection error[/bold red]",
-                        border_style="red",
-                        padding=(1, 2),
-                    )
-                )
-                sys.exit(1)
-
-        upload_data = req_resp.json()
-        presigned_put = upload_data["presigned_put_url"]
-        pending_id = upload_data["pending_upload_id"]
-        new_version = upload_data["new_version"]
-
-        # Step 2 — PUT to mock S3 with progress bar
-        progress = Progress(
-            TextColumn("[bold blue]{task.fields[filename]}"),
-            BarColumn(),
-            DownloadColumn(),
-            TransferSpeedColumn(),
-            TimeRemainingColumn(),
-            console=console,
-        )
-
-        with progress:
-            task_id = progress.add_task("upload", filename=local_path.name, total=size)
-            with _ProgressReader(local_path, task_id, progress) as reader:
-                try:
-                    put_resp = requests.put(
-                        presigned_put,
-                        data=reader,
-                        headers={"Content-Length": str(size)},
-                        timeout=300,
-                    )
-                    put_resp.raise_for_status()
-                except Exception as exc:
-                    console.print(
-                        Panel(
-                            str(exc),
-                            title="[bold red]✗ Upload failed[/bold red]",
-                            border_style="red",
-                            padding=(1, 2),
-                        )
-                    )
-                    sys.exit(1)
-
-        # Step 3 — commit
-        with console.status("[blue]Committing…[/blue]", spinner="dots"):
-            try:
-                commit_resp = self.session.post(
-                    f"{self.base_url}/commit-upload",
-                    json={"pending_upload_id": pending_id},
-                    headers={"Authorization": f"Bearer {self.token}"},
-                    timeout=30,
-                )
-                self._raise_for_status(commit_resp)
-            except (HTTPError, requests.ConnectionError) as exc:
-                console.print(
-                    Panel(
-                        str(exc),
-                        title="[bold red]✗ Commit failed[/bold red]",
-                        border_style="red",
-                        padding=(1, 2),
-                    )
-                )
-                sys.exit(1)
-
-        # Update local vault + manifest
-        vault_path = local_file_path(self.workspace_name, file_path)
-        vault_path.parent.mkdir(parents=True, exist_ok=True)
-        shutil.copy2(local_path, vault_path)
-        update_manifest_entry(file_path, new_version, checksum)
-
-        console.print(
-            Panel(
-                f"[bold]{file_path}[/bold]\n"
-                f"Version  [cyan]{new_version}[/cyan]   "
-                f"SHA-256  [dim]{checksum[:16]}…[/dim]   "
-                f"Size  [dim]{size:,} B[/dim]",
-                title="[bold green]✓ Push complete[/bold green]",
-                border_style="green",
-                padding=(1, 2),
-            )
-        )
-
-    # ------------------------------------------------------------------
-    # Status
-    # ------------------------------------------------------------------
-
-    def status(self) -> None:
-        """Print a Rich table showing the sync state of every tracked file."""
-        self._require_workspace()
-
-        manifest = load_manifest()
-        vault_files = {
-            str(p.relative_to(WORKSPACES_DIR / self.workspace_name))
-            for p in all_local_files(self.workspace_name)
-        }
-        all_keys = set(manifest.keys()) | vault_files
-
-        if not all_keys:
-            console.print("[dim]No tracked files yet.  Run [cyan]study push <file>[/cyan] to start.[/dim]")
-            return
-
-        table = Table(title=f"Workspace: {self.workspace_name}", show_lines=False)
-        table.add_column("File", style="bold", no_wrap=True)
-        table.add_column("Status", justify="center")
-        table.add_column("Version", justify="right")
-        table.add_column("Checksum", style="dim")
-
-        cwd = Path(os.getcwd())
-
-        for fp in sorted(all_keys):
-            entry = manifest.get(fp, {})
-            m_version = entry.get("version", "—")
-            m_checksum = entry.get("checksum", "")
-
-            cwd_path = cwd / fp
-
-            if fp not in manifest:
-                status_cell = "[blue]UNTRACKED[/blue]"
-                checksum_display = "—"
-                version_display = "—"
-            elif not cwd_path.exists():
-                status_cell = "[red]DELETED[/red]"
-                checksum_display = m_checksum[:12] + "…" if m_checksum else "—"
-                version_display = str(m_version)
-            else:
-                current_checksum = sha256_file(cwd_path)
-                if current_checksum == m_checksum:
-                    status_cell = "[green]CLEAN[/green]"
-                else:
-                    status_cell = "[yellow]MODIFIED[/yellow]"
-                checksum_display = current_checksum[:12] + "…"
-                version_display = str(m_version)
-
-            table.add_row(fp, status_cell, version_display, checksum_display)
-
-        console.print(table)