cloudscope 0.1.0__py3-none-any.whl

cloudscope/__init__.py

@@ -0,0 +1,3 @@
+"""CloudScope — TUI for browsing and syncing files across S3, GCS, and Google Drive."""
+
+__version__ = "0.1.0"

cloudscope/__main__.py

@@ -0,0 +1,12 @@
+"""Entry point for `python -m cloudscope` and the `cloudscope` CLI command."""
+
+from cloudscope.app import CloudScopeApp
+
+
+def main() -> None:
+    app = CloudScopeApp()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

cloudscope/app.py

@@ -0,0 +1,100 @@
+"""Main CloudScope application."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+
+from cloudscope.backends.registry import available_backends, get_backend
+from cloudscope.backends import s3 as _s3_reg  # noqa: F401 — triggers register_backend
+from cloudscope.backends import gcs as _gcs_reg  # noqa: F401
+from cloudscope.backends import drive as _drive_reg  # noqa: F401
+from cloudscope.config import AppConfig
+from cloudscope.tui.commands import CloudScopeCommands
+from cloudscope.tui.screens.auth_setup import AuthSetupScreen
+from cloudscope.tui.screens.browse import BrowseScreen
+from cloudscope.tui.screens.settings import SettingsScreen
+from cloudscope.tui.screens.sync_config import SyncConfigScreen
+
+
+class CloudScopeApp(App[None]):
+    """CloudScope — browse and sync cloud storage from your terminal."""
+
+    TITLE = "CloudScope"
+    CSS_PATH = Path(__file__).parent / "tui" / "styles" / "cloudscope.tcss"
+    COMMANDS = {CloudScopeCommands}
+
+    BINDINGS = [
+        Binding("q", "quit", "Quit", show=False, priority=True),
+        Binding("1", "switch_backend('s3')", "S3", show=False, priority=True),
+        Binding("2", "switch_backend('gcs')", "GCS", show=False, priority=True),
+        Binding("3", "switch_backend('drive')", "Drive", show=False, priority=True),
+        Binding("s", "open_sync", "Sync", show=False, priority=True),
+        Binding("comma", "open_settings", "Settings", show=False, priority=True),
+        Binding("a", "open_auth", "Auth", show=False, priority=True),
+    ]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._config = AppConfig.load()
+        self._current_backend = None
+        self._browse_screen: BrowseScreen | None = None
+
+    def on_mount(self) -> None:
+        """Initialize the app — connect to default backend and show browse screen."""
+        backend = self._create_backend(self._config.default_backend)
+        self._current_backend = backend
+        self._browse_screen = BrowseScreen(backend=backend)
+        self.push_screen(self._browse_screen)
+
+    def _create_backend(self, backend_type: str):
+        """Create a backend instance from config."""
+        backend_config = self._config.backends.get(backend_type)
+        profile = backend_config.profile if backend_config else None
+        extra = backend_config.extra if backend_config else {}
+
+        kwargs = {}
+        if backend_type == "s3":
+            if profile:
+                kwargs["profile"] = profile
+            if extra.get("region"):
+                kwargs["region"] = extra["region"]
+        elif backend_type == "gcs":
+            if extra.get("project"):
+                kwargs["project"] = extra["project"]
+            if extra.get("service_account_key"):
+                kwargs["service_account_key"] = extra["service_account_key"]
+        elif backend_type == "drive":
+            if extra.get("client_secrets_path"):
+                kwargs["client_secrets_path"] = extra["client_secrets_path"]
+
+        try:
+            return get_backend(backend_type, **kwargs)
+        except ValueError:
+            self.notify(
+                f"Backend '{backend_type}' not available. Available: {available_backends()}",
+                severity="error",
+            )
+            return get_backend("s3")
+
+    def action_switch_backend(self, backend_type: str) -> None:
+        """Switch to a different cloud backend."""
+        backend = self._create_backend(backend_type)
+        self._current_backend = backend
+        if self._browse_screen:
+            self._browse_screen.set_backend(backend)
+            self.notify(f"Switched to {backend.display_name}")
+
+    def action_open_sync(self) -> None:
+        """Open the sync configuration screen."""
+        self.push_screen(SyncConfigScreen(backend=self._current_backend))
+
+    def action_open_settings(self) -> None:
+        """Open the settings screen."""
+        self.push_screen(SettingsScreen())
+
+    def action_open_auth(self) -> None:
+        """Open the auth setup screen."""
+        self.push_screen(AuthSetupScreen())

cloudscope/auth/aws.py

@@ -0,0 +1,42 @@
+"""AWS credential handling — profile discovery and session creation."""
+
+from __future__ import annotations
+
+import asyncio
+from configparser import ConfigParser
+from pathlib import Path
+from typing import Any
+
+import boto3
+import botocore.session
+
+
+def list_aws_profiles() -> list[str]:
+    """Return available AWS profile names from ~/.aws/credentials and ~/.aws/config."""
+    profiles: set[str] = set()
+    creds_file = Path.home() / ".aws" / "credentials"
+    config_file = Path.home() / ".aws" / "config"
+
+    for filepath in (creds_file, config_file):
+        if filepath.exists():
+            parser = ConfigParser()
+            parser.read(filepath)
+            for section in parser.sections():
+                name = section.removeprefix("profile ").strip()
+                profiles.add(name)
+
+    if not profiles:
+        profiles.add("default")
+    return sorted(profiles)
+
+
+def create_s3_client(profile: str | None = None, region: str | None = None) -> Any:
+    """Create a boto3 S3 client with the given profile."""
+    session = boto3.Session(profile_name=profile, region_name=region)
+    return session.client("s3")
+
+
+async def create_s3_client_async(
+    profile: str | None = None, region: str | None = None
+) -> Any:
+    return await asyncio.to_thread(create_s3_client, profile, region)

cloudscope/auth/drive_oauth.py

@@ -0,0 +1,77 @@
+"""Google Drive OAuth2 authentication flow and token management."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from pathlib import Path
+from typing import Any
+
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from platformdirs import user_config_dir
+
+SCOPES = [
+    "https://www.googleapis.com/auth/drive",
+    "https://www.googleapis.com/auth/drive.metadata.readonly",
+]
+
+CONFIG_DIR = Path(user_config_dir("cloudscope", ensure_exists=True))
+TOKEN_FILE = CONFIG_DIR / "drive_token.json"
+CLIENT_SECRETS_FILE = CONFIG_DIR / "drive_client_secrets.json"
+
+
+def get_drive_credentials(
+    client_secrets_path: str | None = None,
+) -> Credentials:
+    """Get or refresh Google Drive credentials.
+
+    On first run, opens a browser for OAuth consent.
+    Subsequent runs use the stored refresh token.
+    """
+    credentials: Credentials | None = None
+
+    # Try to load existing token
+    if TOKEN_FILE.exists():
+        credentials = Credentials.from_authorized_user_file(str(TOKEN_FILE), SCOPES)
+
+    # Refresh or obtain new credentials
+    if credentials and credentials.expired and credentials.refresh_token:
+        credentials.refresh(Request())
+        _save_token(credentials)
+    elif not credentials or not credentials.valid:
+        secrets_path = client_secrets_path or str(CLIENT_SECRETS_FILE)
+        if not Path(secrets_path).exists():
+            raise FileNotFoundError(
+                f"Google Drive client secrets not found at {secrets_path}. "
+                f"Download OAuth credentials from Google Cloud Console and save to {CLIENT_SECRETS_FILE}"
+            )
+        flow = InstalledAppFlow.from_client_secrets_file(secrets_path, SCOPES)
+        credentials = flow.run_local_server(port=0)
+        _save_token(credentials)
+
+    return credentials
+
+
+async def get_drive_credentials_async(
+    client_secrets_path: str | None = None,
+) -> Credentials:
+    return await asyncio.to_thread(get_drive_credentials, client_secrets_path)
+
+
+def _save_token(credentials: Credentials) -> None:
+    """Save credentials to the token file with restricted permissions."""
+    TOKEN_FILE.write_text(credentials.to_json())
+    TOKEN_FILE.chmod(0o600)
+
+
+def has_drive_credentials() -> bool:
+    """Check if Drive credentials exist (may be expired)."""
+    return TOKEN_FILE.exists()
+
+
+def clear_drive_credentials() -> None:
+    """Remove stored Drive credentials."""
+    if TOKEN_FILE.exists():
+        TOKEN_FILE.unlink()

cloudscope/auth/gcp.py

@@ -0,0 +1,42 @@
+"""GCP credential handling — Application Default Credentials and service accounts."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Any
+
+import google.auth
+from google.cloud import storage
+from google.oauth2 import service_account
+
+
+def create_gcs_client(
+    project: str | None = None,
+    service_account_key: str | None = None,
+) -> storage.Client:
+    """Create a GCS client using ADC or a service account key file."""
+    if service_account_key:
+        key_path = Path(service_account_key)
+        if not key_path.exists():
+            raise FileNotFoundError(f"Service account key not found: {key_path}")
+        credentials = service_account.Credentials.from_service_account_file(
+            str(key_path),
+            scopes=["https://www.googleapis.com/auth/cloud-platform"],
+        )
+        return storage.Client(project=project, credentials=credentials)
+
+    # Fall back to Application Default Credentials
+    credentials, detected_project = google.auth.default(
+        scopes=["https://www.googleapis.com/auth/cloud-platform"]
+    )
+    return storage.Client(
+        project=project or detected_project, credentials=credentials
+    )
+
+
+async def create_gcs_client_async(
+    project: str | None = None,
+    service_account_key: str | None = None,
+) -> storage.Client:
+    return await asyncio.to_thread(create_gcs_client, project, service_account_key)

cloudscope/backends/base.py

@@ -0,0 +1,98 @@
+"""CloudBackend Protocol — the central abstraction all backends implement."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator, Callable
+from typing import Protocol, runtime_checkable
+
+from cloudscope.models.cloud_file import CloudFile
+
+ProgressCallback = Callable[[int, int], None]  # (bytes_transferred, total_bytes)
+
+
+class CloudScopeError(Exception):
+    """Base exception for all cloudscope errors."""
+
+
+class AuthenticationError(CloudScopeError):
+    """Credentials are invalid or expired."""
+
+
+class PermissionError(CloudScopeError):  # noqa: A001
+    """Insufficient permissions for the requested operation."""
+
+
+class NotFoundError(CloudScopeError):
+    """The requested file, folder, or container does not exist."""
+
+
+class QuotaError(CloudScopeError):
+    """Rate limit or storage quota exceeded."""
+
+
+class NetworkError(CloudScopeError):
+    """Connectivity failure."""
+
+
+@runtime_checkable
+class CloudBackend(Protocol):
+    """Unified interface for cloud storage backends."""
+
+    @property
+    def backend_type(self) -> str: ...
+
+    @property
+    def display_name(self) -> str: ...
+
+    # --- Connection ---
+    async def connect(self) -> None: ...
+
+    async def disconnect(self) -> None: ...
+
+    async def is_connected(self) -> bool: ...
+
+    # --- Container listing ---
+    async def list_containers(self) -> list[str]: ...
+
+    # --- Browsing ---
+    async def list_files(
+        self,
+        container: str,
+        prefix: str = "",
+        recursive: bool = False,
+    ) -> list[CloudFile]: ...
+
+    async def stat(self, container: str, path: str) -> CloudFile: ...
+
+    async def exists(self, container: str, path: str) -> bool: ...
+
+    # --- Transfer ---
+    async def download(
+        self,
+        container: str,
+        remote_path: str,
+        local_path: str,
+        progress_callback: ProgressCallback | None = None,
+    ) -> None: ...
+
+    async def upload(
+        self,
+        container: str,
+        local_path: str,
+        remote_path: str,
+        progress_callback: ProgressCallback | None = None,
+    ) -> CloudFile: ...
+
+    # --- Mutation ---
+    async def delete(self, container: str, path: str) -> None: ...
+
+    async def create_folder(self, container: str, path: str) -> CloudFile: ...
+
+    async def move(self, container: str, src: str, dst: str) -> CloudFile: ...
+
+    async def copy(self, container: str, src: str, dst: str) -> CloudFile: ...
+
+    # --- Sync support ---
+    async def list_files_recursive(
+        self, container: str, prefix: str = ""
+    ) -> AsyncIterator[CloudFile]: ...