uplaod to gcs cli

Author: shadowfax92

packages/browseros/build/build.py

@@ -51,7 +51,7 @@ def load_env_file():
 from modules.inject import inject_version
 from modules.configure import configure
 from modules.compile import build
-from modules.gcs import upload_package_artifacts, upload_signed_artifacts
+from modules.gcs import upload_package_artifacts, upload_signed_artifacts, handle_upload_dist
 
 # Platform-specific imports
 if IS_MACOS:
@@ -568,6 +568,17 @@ def build_main(
     default=False,
     help="Skip uploading artifacts to Google Cloud Storage",
 )
+@click.option(
+    "--upload-dist",
+    type=click.Path(exists=True, path_type=Path),
+    help="Upload pre-built artifacts from dist/<version> directory to GCS: --upload-dist dist/61",
+)
+@click.option(
+    "--platform",
+    type=click.Choice(["macos", "linux", "win"]),
+    default=None,
+    help="Override platform for GCS upload (auto-detected if not specified)",
+)
 def main(
     config,
     clean,
@@ -586,6 +597,8 @@ def main(
     patch_interactive,
     patch_commit,
     no_gcs_upload,
+    upload_dist,
+    platform,
 ):
     """Simple build system for Nxtscape Browser"""
 
@@ -662,6 +675,17 @@ def main(
         else:
             sys.exit(1)
 
+    # Handle upload-dist command
+    if upload_dist:
+        # Get root directory
+        root_dir = Path(__file__).parent.parent
+
+        # Call the upload handler from gcs module
+        if handle_upload_dist(upload_dist, root_dir, platform_override=platform):
+            sys.exit(0)
+        else:
+            sys.exit(1)
+
     # Regular build workflow
     build_main(
         config_file=config,

packages/browseros/build/modules/gcs.py

@@ -4,8 +4,9 @@
 """
 
 import os
+import sys
 from pathlib import Path
-from typing import List, Optional
+from typing import List, Optional, Tuple
 from context import BuildContext
 from utils import (
     log_info,
@@ -14,6 +15,7 @@
     log_warning,
     IS_WINDOWS,
     IS_MACOS,
+    IS_LINUX,
     join_paths,
 )
 
@@ -29,10 +31,38 @@
 # Service account file name
 SERVICE_ACCOUNT_FILE = "gclient.json"
 
+# GCS bucket configuration
+GCS_BUCKET_NAME = "nxtscape"
 
-def upload_to_gcs(ctx: BuildContext, file_paths: List[Path]) -> tuple[bool, List[str]]:
+
+def _get_platform_dir(platform_override: Optional[str] = None) -> str:
+    """Get platform directory name for GCS path"""
+    if platform_override:
+        return platform_override
+
+    if IS_WINDOWS:
+        return "win"
+    elif IS_MACOS:
+        return "macos"
+    else:
+        return "linux"
+
+
+def upload_to_gcs(
+    ctx: BuildContext,
+    file_paths: List[Path],
+    platform_override: Optional[str] = None
+) -> Tuple[bool, List[str]]:
     """Upload build artifacts to Google Cloud Storage
-    Returns: (success, list of GCS URIs)"""
+
+    Args:
+        ctx: BuildContext with root_dir and nxtscape_version
+        file_paths: List of file paths to upload
+        platform_override: Optional platform override (macos/linux/win)
+
+    Returns:
+        (success, list of GCS URIs)
+    """
     if not GCS_AVAILABLE:
         log_warning("google-cloud-storage not installed. Skipping GCS upload.")
         log_info("Install with: pip install google-cloud-storage")
@@ -43,18 +73,12 @@ def upload_to_gcs(ctx: BuildContext, file_paths: List[Path]) -> tuple[bool, List
         return True, []
 
     # Determine platform subdirectory
-    if IS_WINDOWS:
-        platform_dir = "win"
-    elif IS_MACOS:
-        platform_dir = "macos"
-    else:
-        platform_dir = "linux"
+    platform_dir = _get_platform_dir(platform_override)
 
     # Build GCS path: gs://nxtscape/resources/<version>/<platform>/
-    bucket_name = "nxtscape"
     gcs_prefix = f"resources/{ctx.nxtscape_version}/{platform_dir}"
 
-    log_info(f"\n☁️  Uploading artifacts to gs://{bucket_name}/{gcs_prefix}/")
+    log_info(f"\n☁️  Uploading artifacts to gs://{GCS_BUCKET_NAME}/{gcs_prefix}/")
 
     # Check for service account file
     service_account_path = join_paths(ctx.root_dir, SERVICE_ACCOUNT_FILE)
@@ -71,7 +95,7 @@ def upload_to_gcs(ctx: BuildContext, file_paths: List[Path]) -> tuple[bool, List
             str(service_account_path)
         )
         client = storage.Client(credentials=credentials)
-        bucket = client.bucket(bucket_name)
+        bucket = client.bucket(GCS_BUCKET_NAME)
 
         uploaded_files = []
         gcs_uris = []
@@ -93,8 +117,8 @@ def upload_to_gcs(ctx: BuildContext, file_paths: List[Path]) -> tuple[bool, List
                 # Note: With uniform bucket-level access, objects inherit bucket's IAM policies
                 # No need to set individual object ACLs
 
-                public_url = f"https://storage.googleapis.com/{bucket_name}/{blob_name}"
-                gcs_uri = f"gs://{bucket_name}/{blob_name}"
+                public_url = f"https://storage.googleapis.com/{GCS_BUCKET_NAME}/{blob_name}"
+                gcs_uri = f"gs://{GCS_BUCKET_NAME}/{blob_name}"
                 uploaded_files.append(public_url)
                 gcs_uris.append(gcs_uri)
                 log_success(f"✓ Uploaded: {public_url}")
@@ -194,3 +218,149 @@ def download_from_gcs(
     except Exception as e:
         log_error(f"Failed to download from GCS: {e}")
         return False
+
+
+def _detect_artifacts(dist_path: Path, platform_override: Optional[str] = None) -> List[Path]:
+    """Detect artifacts in a dist directory based on platform
+
+    Args:
+        dist_path: Path to the dist/<version> directory
+        platform_override: Optional platform override (macos/linux/win)
+
+    Returns:
+        List of artifact file paths found
+    """
+    artifacts = []
+
+    # Determine which file types to look for
+    if platform_override:
+        if platform_override == "macos":
+            patterns = ["*.dmg"]
+        elif platform_override == "win":
+            patterns = ["*.exe", "*.zip"]
+        elif platform_override == "linux":
+            patterns = ["*.AppImage"]
+        else:
+            log_error(f"Invalid platform: {platform_override}. Must be macos/linux/win")
+            return []
+    else:
+        # Auto-detect based on current platform
+        if IS_MACOS:
+            patterns = ["*.dmg"]
+        elif IS_WINDOWS:
+            patterns = ["*.exe", "*.zip"]
+        else:  # Linux
+            patterns = ["*.AppImage"]
+
+    # Find all matching files
+    for pattern in patterns:
+        artifacts.extend(dist_path.glob(pattern))
+
+    return sorted(artifacts)
+
+
+def handle_upload_dist(
+    dist_path: Path,
+    root_dir: Path,
+    platform_override: Optional[str] = None
+) -> bool:
+    """Upload pre-built artifacts from a dist directory to GCS
+
+    This is the main entry point for manual uploads of already-built artifacts.
+
+    Args:
+        dist_path: Path to dist/<version> directory containing artifacts
+        root_dir: Root directory of the project (for finding gclient.json)
+        platform_override: Optional platform override (macos/linux/win)
+
+    Returns:
+        True if successful, False otherwise
+
+    Example:
+        handle_upload_dist(Path("dist/61"), Path("."), platform_override="macos")
+    """
+    log_info("=" * 60)
+    log_info("📤 Manual GCS Upload")
+    log_info("=" * 60)
+
+    # 1. Validate dist_path exists
+    if not dist_path.exists():
+        log_error(f"Distribution directory does not exist: {dist_path}")
+        return False
+
+    if not dist_path.is_dir():
+        log_error(f"Path is not a directory: {dist_path}")
+        return False
+
+    # 2. Extract version from path (assume dist/<version> structure)
+    version = dist_path.name
+    log_info(f"📦 Version detected: {version}")
+
+    # 3. Determine platform
+    platform_dir = _get_platform_dir(platform_override)
+    if platform_override:
+        log_info(f"🖥️  Platform (override): {platform_dir}")
+    else:
+        log_info(f"🖥️  Platform (auto-detected): {platform_dir}")
+
+    # 4. Scan for artifacts
+    log_info(f"\n🔍 Scanning for artifacts in: {dist_path}")
+    artifacts = _detect_artifacts(dist_path, platform_override)
+
+    if not artifacts:
+        log_warning("No artifacts found to upload")
+        log_info("\nExpected file types by platform:")
+        log_info("  - macOS: *.dmg")
+        log_info("  - Windows: *.exe, *.zip")
+        log_info("  - Linux: *.AppImage")
+        return False
+
+    # 5. Preview files
+    log_info(f"\n📋 Found {len(artifacts)} artifact(s):")
+    total_size = 0
+    for artifact in artifacts:
+        size_mb = artifact.stat().st_size / (1024 * 1024)
+        total_size += size_mb
+        log_info(f"  - {artifact.name} ({size_mb:.2f} MB)")
+
+    log_info(f"\nTotal size: {total_size:.2f} MB")
+    log_info(f"Upload destination: gs://{GCS_BUCKET_NAME}/resources/{version}/{platform_dir}/")
+
+    # 6. Create minimal BuildContext for upload
+    # BuildContext will try to load chromium_src, but we'll provide a dummy one
+    # since we don't need it for uploads
+    try:
+        ctx = BuildContext(
+            root_dir=root_dir,
+            chromium_src=Path("/dev/null"),  # Dummy path, won't be used
+            architecture="",  # Not needed for upload
+            build_type="release",  # Not needed for upload
+        )
+        # Override the version with what we detected
+        ctx.nxtscape_version = version
+    except Exception as e:
+        # If BuildContext fails, we can still upload with minimal info
+        log_warning(f"Could not create full BuildContext: {e}")
+        log_info("Creating minimal context for upload...")
+
+        # Create a simple object with just what we need
+        class MinimalContext:
+            def __init__(self, root_dir: Path, version: str):
+                self.root_dir = root_dir
+                self.nxtscape_version = version
+
+        ctx = MinimalContext(root_dir, version)
+
+    # 7. Upload using existing upload_to_gcs function
+    success, gcs_uris = upload_to_gcs(ctx, artifacts, platform_override=platform_override)
+
+    if success:
+        log_success("\n✅ Upload completed successfully!")
+        if gcs_uris:
+            log_info("\nUploaded URIs:")
+            for uri in gcs_uris:
+                log_info(f"  {uri}")
+        return True
+    else:
+        log_error("\n❌ Upload failed")
+        return False