qbraid-cli 0.12.0a2__tar.gz → 0.12.0a3__tar.gz

{qbraid_cli-0.12.0a2/qbraid_cli.egg-info → qbraid_cli-0.12.0a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qbraid-cli
-Version: 0.12.0a2
+Version: 0.12.0a3
 Summary: Command Line Interface for interacting with all parts of the qBraid platform.
 Author-email: qBraid Development Team <contact@qbraid.com>
 License-Expression: LicenseRef-Proprietary

{qbraid_cli-0.12.0a2 → qbraid_cli-0.12.0a3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qbraid-cli"
-version = "0.12.0a2"
+version = "0.12.0a3"
 description = "Command Line Interface for interacting with all parts of the qBraid platform."
 readme = "README.md"
 authors = [{ name = "qBraid Development Team", email = "contact@qbraid.com" }]

{qbraid_cli-0.12.0a2 → qbraid_cli-0.12.0a3}/qbraid_cli/envs/app.py

@@ -440,6 +440,179 @@ def envs_available():
         console.print("[dim]Create custom environments with: qbraid envs create[/dim]")
 
 
+@envs_app.command(name="info")
+def envs_info(
+    identifier: str = typer.Argument(..., help="Environment identifier (env_id or slug)"),
+):
+    """
+    Get detailed information about an environment.
+
+    Accepts either a local env_id or a cloud slug. Shows information from
+    both local registry and cloud catalog when available.
+
+    Examples:
+        $ qbraid envs info qiskit_1.0       # By slug (cloud + local if installed)
+        $ qbraid envs info a1b2             # By env_id (local only)
+        $ qbraid envs info my_custom_abc123 # Custom environment
+    """
+    from qbraid_core.services.environments import EnvironmentRegistryManager
+
+    console = Console()
+
+    # Try to find in local registry first
+    local_entry = None
+    local_entries = []
+    slug_to_query = None
+
+    try:
+        registry = EnvironmentRegistryManager()
+
+        # First try by env_id (exact match)
+        local_entry = registry.find_by_env_id(identifier)
+        if local_entry:
+            local_entries = [local_entry]
+            slug_to_query = local_entry.slug  # May be None for local-only envs
+        else:
+            # Try by slug (may return multiple installations)
+            local_entries = registry.find_all_by_slug(identifier)
+            if local_entries:
+                slug_to_query = identifier
+            else:
+                # Not found locally, try cloud with this identifier as slug
+                slug_to_query = identifier
+    except Exception:
+        # Registry not available - try cloud only
+        slug_to_query = identifier
+
+    # Try to fetch from cloud API
+    cloud_env = None
+    if slug_to_query:
+        try:
+            from qbraid_core.services.environments.client import EnvironmentManagerClient
+
+            def get_cloud_info():
+                client = EnvironmentManagerClient()
+                return client.get_environment_by_slug(slug_to_query)
+
+            cloud_env = run_progress_task(
+                get_cloud_info,
+                description="Fetching environment details...",
+                error_message="Failed to fetch from cloud",
+            )
+        except Exception:
+            # Cloud lookup failed - that's OK if we have local info
+            pass
+
+    # If nothing found anywhere, exit with error
+    if not local_entries and not cloud_env:
+        console.print(f"[red]❌ Environment not found:[/red] {identifier}")
+        console.print("[dim]Not found in local registry or cloud catalog.[/dim]")
+        raise typer.Exit(1)
+
+    # --- Display Cloud Info (if available) ---
+    if cloud_env:
+        name = cloud_env.get("displayName") or cloud_env.get("name") or "N/A"
+        description = cloud_env.get("description") or "No description"
+        owner = cloud_env.get("owner") or cloud_env.get("userId") or "Unknown"
+        python_version = cloud_env.get("pythonVersion") or "Unknown"
+        visibility = cloud_env.get("visibility") or "private"
+        tags = cloud_env.get("tags") or []
+        image_tag = cloud_env.get("imageTag") or cloud_env.get("image_tag") or "N/A"
+        available = cloud_env.get("available_for_installation", False)
+
+        visibility_colors = {"public": "green", "private": "yellow", "shared": "cyan"}
+        vis_color = visibility_colors.get(visibility, "white")
+
+        console.print(f"\n📦 [bold]{name}[/bold]")
+        console.print(f"   [dim]{description}[/dim]")
+
+        console.print(f"\n[bold]☁️  Cloud Info:[/bold]")
+        console.print(f"   Slug:            {slug_to_query}")
+        console.print(f"   Owner:           {owner}")
+        console.print(f"   Python:          {python_version}")
+        console.print(f"   Visibility:      [{vis_color}]{visibility}[/{vis_color}]")
+        console.print(f"   Image Tag:       {image_tag}")
+
+        if tags:
+            console.print(f"   Tags:            {', '.join(tags)}")
+
+        # Publish status
+        review_status = cloud_env.get("reviewStatus")
+        if review_status:
+            status_colors = {
+                "none": "dim",
+                "requested": "yellow",
+                "pending": "cyan",
+                "approved": "green",
+                "denied": "red",
+            }
+            color = status_colors.get(review_status, "white")
+            console.print(f"   Publish Status:  [{color}]{review_status}[/{color}]")
+
+    # --- Display Local Info (if available) ---
+    if local_entries:
+        # If no cloud info, show header from local entry
+        if not cloud_env:
+            entry = local_entries[0]
+            console.print(f"\n📦 [bold]{entry.name}[/bold]")
+            if entry.description:
+                console.print(f"   [dim]{entry.description}[/dim]")
+
+        console.print(f"\n[bold]💻 Local Installation{'s' if len(local_entries) > 1 else ''}:[/bold]")
+
+        for entry in local_entries:
+            kernel_status = "✓ kernel" if entry.has_kernel else "○ no kernel"
+            env_type = entry.type.value if hasattr(entry.type, "value") else str(entry.type)
+
+            console.print(f"\n   [bold]env_id:[/bold] {entry.env_id}")
+            console.print(f"   Path:            {entry.path}")
+            console.print(f"   Type:            {env_type}")
+            if entry.python_version:
+                console.print(f"   Python:          {entry.python_version}")
+            if entry.python_executable:
+                console.print(f"   Executable:      {entry.python_executable}")
+            if entry.platform:
+                console.print(f"   Platform:        {entry.platform}")
+            if entry.kernel_name:
+                console.print(f"   Kernel:          {entry.kernel_name} [{kernel_status}]")
+            else:
+                console.print(f"   Kernel:          [{kernel_status}]")
+            if entry.shell_prompt:
+                console.print(f"   Shell Prompt:    {entry.shell_prompt}")
+            if entry.installed_at:
+                console.print(f"   Installed:       {entry.installed_at}")
+            elif entry.registered_at:
+                console.print(f"   Registered:      {entry.registered_at}")
+            if entry.slug:
+                console.print(f"   Slug:            {entry.slug}")
+    elif cloud_env:
+        console.print(f"\n[bold]💻 Local Installation:[/bold]")
+        console.print(f"   [dim]Not installed locally[/dim]")
+
+    # --- Show Actions ---
+    console.print(f"\n[bold]Actions:[/bold]")
+
+    if cloud_env:
+        available = cloud_env.get("available_for_installation", False)
+        visibility = cloud_env.get("visibility", "private")
+
+        if available and not local_entries:
+            console.print(f"   Install:  [bold]qbraid envs install {slug_to_query}[/bold]")
+        if visibility == "private":
+            console.print(f"   Share:    [bold]qbraid envs share {slug_to_query} <email>[/bold]")
+            console.print(f"   Publish:  [bold]qbraid envs publish {slug_to_query}[/bold]")
+
+    if local_entries:
+        entry = local_entries[0]
+        if not entry.slug:
+            # Local-only environment - can be uploaded
+            console.print(f"   Upload:   [bold]qbraid envs upload {entry.env_id}[/bold]")
+        if not entry.has_kernel:
+            console.print(f"   Add kernel: [bold]qbraid kernels add {entry.env_id}[/bold]")
+        console.print(f"   Activate: [bold]qbraid envs activate {entry.env_id}[/bold]")
+        console.print(f"   Remove:   [bold]qbraid envs remove {entry.env_id}[/bold]")
+
+
 @envs_app.command(name="install")
 def envs_install(
     env_slug: str = typer.Argument(..., help="Environment slug to install (from 'qbraid envs available')"),
@@ -572,130 +745,603 @@ def envs_install(
         raise typer.Exit(1)
 
 
-@envs_app.command(name="publish")
-def envs_publish(
-    slug: str = typer.Argument(..., help="Environment slug identifier"),
-    path: Optional[Path] = typer.Option(
-        None,
-        "--path",
-        "-p",
-        help="Path to environment directory (default: lookup from registry)"
+@envs_app.command(name="upload")
+def envs_upload(
+    identifier: str = typer.Argument(
+        ..., help="Environment name (if unique) or env_id to upload"
     ),
     overwrite: bool = typer.Option(
         False,
         "--overwrite",
         "-o",
-        help="Overwrite existing published environment"
+        help="Overwrite existing uploaded environment"
     ),
 ):
     """
-    Publish environment to qBraid cloud storage for global distribution.
+    Upload environment to qBraid cloud storage (private by default).
 
-    This command packages and uploads your environment to make it available
-    for installation by other users via 'qbraid envs install'.
+    This uploads your local environment to make it available for sharing
+    with specific users. Use 'qbraid envs publish' after upload to request
+    public visibility.
 
     Examples:
-        $ qbraid envs publish my_custom_env
-        $ qbraid envs publish my_env --path ~/my_environment
-        $ qbraid envs publish my_env --overwrite
+        $ qbraid envs upload my_custom_env
+        $ qbraid envs upload a1b2 --overwrite
     """
-    from rich.console import Console
-    from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn
+    import asyncio
     from qbraid_core.services.environments.client import EnvironmentManagerClient
-    from qbraid_core.services.environments.registry import EnvironmentRegistryManager
 
     console = Console()
 
-    # Determine environment path
-    if path:
-        env_path = path.expanduser().resolve()
-        if not env_path.exists():
-            console.print(f"[red]❌ Error:[/red] Path does not exist: {env_path}")
-            raise typer.Exit(1)
-    else:
-        # Look up from registry by slug
-        try:
-            registry_mgr = EnvironmentRegistryManager()
-            found = registry_mgr.find_by_slug(slug)
-            if not found:
-                console.print(f"[red]❌ Error:[/red] Environment with slug '{slug}' not found in registry")
-                console.print("\n[yellow]💡 Tip:[/yellow] Use --path to specify environment directory manually.")
-                raise typer.Exit(1)
-            env_id, env = found
-            env_path = Path(env.path)
-        except Exception as err:
-            console.print(f"[red]❌ Error:[/red] Failed to locate environment: {err}")
-            console.print("\n[yellow]💡 Tip:[/yellow] Use --path to specify environment directory manually.")
-            raise typer.Exit(1)
-
-    console.print(f"🚀 Publishing environment: [bold]{slug}[/bold]")
-    console.print(f"📂 Source: {env_path}\n")
-
-    # Define async function
-    async def publish_environment_async():
-        """Async wrapper for environment publishing."""
+    async def upload_environment_async():
+        """Async wrapper for environment upload."""
         client = EnvironmentManagerClient()
 
-        # Progress tracking
-        stages = {"archive": False, "upload": False}
-
-        def progress_callback(stage: str, completed: int, total: int):
-            """Track progress across stages."""
-            stages[stage] = True
-
-        with Progress(
+        progress_columns = (
             SpinnerColumn(),
-            TextColumn("[progress.description]{task.description}"),
+            TextColumn("{task.description}"),
             BarColumn(),
             TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
-            console=console,
-        ) as progress:
-            # Add tasks
-            archive_task = progress.add_task("📦 Creating archive...", total=100)
-            upload_task = progress.add_task("☁️  Uploading to cloud...", total=100)
-
-            try:
-                # TODO: Update this when env_share_publish branch is merged
-                # This will use remote_publish_environment and handle directory renaming
-                raise NotImplementedError(
-                    "Publish command will be updated when env_share_publish branch is merged. "
-                    "It will use remote_publish_environment to get slug from API, "
-                    "rename directory from env_id to slug, update paths, and upload."
-                )
-                # result = await client.publish_environment(
-                #     slug=slug,
-                #     env_path=str(env_path),
-                #     overwrite=overwrite,
-                #     progress_callback=progress_callback
-                # )
+            TimeElapsedColumn(),
+        )
 
-                # Update progress bars
-                if stages.get("archive"):
-                    progress.update(archive_task, completed=100)
-                if stages.get("upload"):
-                    progress.update(upload_task, completed=100)
+        with Progress(*progress_columns, console=console, transient=False) as progress:
+            tasks: dict[str, int] = {}
+
+            def get_task(stage: str, description: str, total: Optional[int]) -> int:
+                task_id = tasks.get(stage)
+                if task_id is None:
+                    task_total = total if total and total > 0 else 100
+                    task_id = progress.add_task(description, total=task_total)
+                    tasks[stage] = task_id
+                return task_id
+
+            def progress_callback(stage: str, completed: int, total: int) -> None:
+                total_value = total if total and total > 0 else 100
+                if stage == "prepare":
+                    task_id = get_task("prepare", "📋 Preparing environment...", total_value)
+                    progress.update(task_id, completed=completed, total=total_value)
+                elif stage == "archive":
+                    task_id = get_task("archive", "📦 Creating archive...", total_value)
+                    progress.update(task_id, completed=completed, total=total_value)
+                elif stage == "upload":
+                    task_id = get_task("upload", "☁️  Uploading to cloud...", total_value)
+                    progress.update(task_id, completed=completed, total=total_value)
+
+            result = await client.upload_environment(
+                identifier=identifier,
+                overwrite=overwrite,
+                progress_callback=progress_callback,
+            )
 
-                return result
+        return result
 
-            except Exception as err:
-                raise err
+    console.print(f"🚀 Uploading environment: [bold]{identifier}[/bold]\n")
 
-    # Run async function
-    import asyncio
     try:
-        result = asyncio.run(publish_environment_async())
+        result = asyncio.run(upload_environment_async())
+
+        console.print(f"\n[green]✅ Upload completed![/green]")
+        console.print(f"📍 Slug: [bold]{result.get('slug', 'N/A')}[/bold]")
+        console.print(f"🆔 Env ID: {result.get('env_id', 'N/A')}")
+        if result.get('bucket'):
+            console.print(f"☁️  Bucket: {result.get('bucket')}")
 
-        console.print(f"\n[green]✅ Published successfully![/green]")
-        console.print(f"📍 Bucket: {result.get('bucket', 'N/A')}")
-        console.print(f"📄 Path: {result.get('path', 'N/A')}")
-        console.print(f"\n🎯 Users can now install with:")
-        console.print(f"   [bold cyan]qbraid envs install {slug}[/bold cyan]")
+        console.print(f"\n🎯 Next steps:")
+        console.print(f"   • Share privately: [bold]qbraid envs share {result.get('slug')} <email>[/bold]")
+        console.print(f"   • Request public: [bold]qbraid envs publish {result.get('slug')}[/bold]")
 
     except KeyboardInterrupt:
-        console.print("\n[yellow]⚠️  Publishing cancelled by user[/yellow]")
+        console.print("\n[yellow]⚠️  Upload cancelled by user[/yellow]")
+        raise typer.Exit(1)
+    except Exception as err:
+        console.print(f"\n[red]❌ Upload failed:[/red] {err}")
+        raise typer.Exit(1)
+
+
+@envs_app.command(name="publish")
+def envs_publish(
+    slug: str = typer.Argument(..., help="Environment slug (from upload)"),
+):
+    """
+    Request to publish environment to the public catalog.
+
+    This submits your uploaded environment for admin review. Once approved,
+    it will be publicly visible and installable by all users.
+
+    The environment must be uploaded first with 'qbraid envs upload'.
+
+    Examples:
+        $ qbraid envs publish my_env_abc123
+    """
+    from qbraid_core.services.environments.client import EnvironmentManagerClient
+
+    console = Console()
+
+    def request_publish():
+        client = EnvironmentManagerClient()
+        return client.request_publish(slug)
+
+    console.print(f"📤 Requesting to publish: [bold]{slug}[/bold]\n")
+
+    try:
+        result = run_progress_task(
+            request_publish,
+            description="Submitting publish request...",
+            error_message="Failed to submit publish request"
+        )
+
+        console.print(f"\n[green]✅ Publish request submitted![/green]")
+        console.print(f"📍 Slug: [bold]{slug}[/bold]")
+        console.print(f"📊 Status: [yellow]requested[/yellow]")
+        console.print(f"\n💡 Your request will be reviewed by qBraid admins.")
+        console.print(f"   Check status with: [bold]qbraid envs publish-status {slug}[/bold]")
+
+    except Exception as err:
+        error_msg = str(err)
+        if "already" in error_msg.lower():
+            console.print(f"[yellow]⚠️  {error_msg}[/yellow]")
+        else:
+            console.print(f"[red]❌ Failed to request publish:[/red] {err}")
         raise typer.Exit(1)
+
+
+@envs_app.command(name="publish-status")
+def envs_publish_status(
+    slug: str = typer.Argument(..., help="Environment slug to check"),
+):
+    """
+    Check the publishing status of an environment.
+
+    Status values:
+        - none: Not submitted for publishing
+        - requested: Waiting for admin review
+        - pending: Under admin review
+        - approved: Published to public catalog
+        - denied: Publish request was denied
+
+    Examples:
+        $ qbraid envs publish-status my_env_abc123
+    """
+    from qbraid_core.services.environments.client import EnvironmentManagerClient
+
+    console = Console()
+
+    def get_status():
+        client = EnvironmentManagerClient()
+        return client.get_publish_status(slug)
+
+    try:
+        status = run_progress_task(
+            get_status,
+            description="Checking publish status...",
+            error_message="Failed to get publish status"
+        )
+
+        # Color-code status
+        status_colors = {
+            "none": "dim",
+            "requested": "yellow",
+            "pending": "cyan",
+            "approved": "green",
+            "denied": "red",
+        }
+        color = status_colors.get(status, "white")
+
+        console.print(f"\n📊 Publish Status for [bold]{slug}[/bold]")
+        console.print(f"   Status: [{color}]{status}[/{color}]")
+
+        # Show helpful next steps
+        if status == "none":
+            console.print(f"\n💡 To request publishing: [bold]qbraid envs publish {slug}[/bold]")
+        elif status == "requested":
+            console.print(f"\n⏳ Waiting for admin review...")
+            console.print(f"   To cancel: [bold]qbraid envs publish-cancel {slug}[/bold]")
+        elif status == "pending":
+            console.print(f"\n🔍 Currently under admin review...")
+        elif status == "approved":
+            console.print(f"\n🎉 Environment is publicly available!")
+            console.print(f"   Install with: [bold]qbraid envs install {slug}[/bold]")
+        elif status == "denied":
+            console.print(f"\n❌ Publish request was denied.")
+            console.print(f"   To resubmit: [bold]qbraid envs publish {slug}[/bold]")
+
     except Exception as err:
-        console.print(f"\n[red]❌ Publishing failed:[/red] {err}")
+        console.print(f"[red]❌ Failed to get status:[/red] {err}")
+        raise typer.Exit(1)
+
+
+@envs_app.command(name="publish-cancel")
+def envs_publish_cancel(
+    slug: str = typer.Argument(..., help="Environment slug"),
+):
+    """
+    Cancel a pending publish request.
+
+    This withdraws your publish request before it's approved.
+    You can resubmit later with 'qbraid envs publish'.
+
+    Examples:
+        $ qbraid envs publish-cancel my_env_abc123
+    """
+    from qbraid_core.services.environments.client import EnvironmentManagerClient
+
+    console = Console()
+
+    def revoke_request():
+        client = EnvironmentManagerClient()
+        return client.revoke_publish_request(slug)
+
+    console.print(f"🚫 Cancelling publish request for: [bold]{slug}[/bold]\n")
+
+    try:
+        result = run_progress_task(
+            revoke_request,
+            description="Cancelling publish request...",
+            error_message="Failed to cancel publish request"
+        )
+
+        console.print(f"[green]✅ Publish request cancelled.[/green]")
+        console.print(f"   Environment remains private/shared only.")
+        console.print(f"\n💡 To resubmit: [bold]qbraid envs publish {slug}[/bold]")
+
+    except Exception as err:
+        console.print(f"[red]❌ Failed to cancel:[/red] {err}")
+        raise typer.Exit(1)
+
+
+@envs_app.command(name="publish-review")
+def envs_publish_review(
+    slug: str = typer.Argument(..., help="Environment slug to review"),
+):
+    """
+    (Admin) Mark an environment as under review.
+
+    This transitions the environment from 'requested' to 'pending' status,
+    indicating an admin is actively reviewing it.
+
+    Examples:
+        $ qbraid envs publish-review my_env_abc123
+    """
+    from qbraid_core.services.environments.client import EnvironmentManagerClient
+
+    console = Console()
+
+    def set_pending():
+        client = EnvironmentManagerClient()
+        return client.set_publish_pending(slug)
+
+    console.print(f"🔍 Marking as under review: [bold]{slug}[/bold]\n")
+
+    try:
+        result = run_progress_task(
+            set_pending,
+            description="Updating status to pending...",
+            error_message="Failed to update status"
+        )
+
+        console.print(f"[green]✅ Environment marked as under review.[/green]")
+        console.print(f"   Status: [cyan]pending[/cyan]")
+        console.print(f"\n💡 Next steps:")
+        console.print(f"   • Approve: [bold]qbraid envs publish-approve {slug}[/bold]")
+        console.print(f"   • Deny: [bold]qbraid envs publish-deny {slug} --message \"reason\"[/bold]")
+
+    except Exception as err:
+        error_msg = str(err)
+        if "permission" in error_msg.lower() or "admin" in error_msg.lower():
+            console.print(f"[red]❌ Admin access required.[/red]")
+        else:
+            console.print(f"[red]❌ Failed:[/red] {err}")
+        raise typer.Exit(1)
+
+
+@envs_app.command(name="publish-approve")
+def envs_publish_approve(
+    slug: str = typer.Argument(..., help="Environment slug to approve"),
+):
+    """
+    (Admin) Approve and publish an environment to the public catalog.
+
+    This makes the environment publicly visible and installable by all users.
+
+    Examples:
+        $ qbraid envs publish-approve my_env_abc123
+    """
+    from qbraid_core.services.environments.client import EnvironmentManagerClient
+
+    console = Console()
+
+    def approve():
+        client = EnvironmentManagerClient()
+        return client.approve_publish(slug)
+
+    console.print(f"✅ Approving environment: [bold]{slug}[/bold]\n")
+
+    try:
+        result = run_progress_task(
+            approve,
+            description="Approving and publishing...",
+            error_message="Failed to approve"
+        )
+
+        console.print(f"[green]✅ Environment published successfully![/green]")
+        console.print(f"   Slug: [bold]{slug}[/bold]")
+        console.print(f"   Visibility: [green]public[/green]")
+        console.print(f"\n🎉 Users can now install with:")
+        console.print(f"   [bold]qbraid envs install {slug}[/bold]")
+
+    except Exception as err:
+        error_msg = str(err)
+        if "permission" in error_msg.lower() or "admin" in error_msg.lower():
+            console.print(f"[red]❌ Admin access required.[/red]")
+        else:
+            console.print(f"[red]❌ Failed:[/red] {err}")
+        raise typer.Exit(1)
+
+
+@envs_app.command(name="publish-deny")
+def envs_publish_deny(
+    slug: str = typer.Argument(..., help="Environment slug to deny"),
+    message: Optional[str] = typer.Option(
+        None,
+        "--message",
+        "-m",
+        help="Reason for denial (sent to owner)"
+    ),
+):
+    """
+    (Admin) Deny a publish request.
+
+    The owner will be notified with the denial reason.
+
+    Examples:
+        $ qbraid envs publish-deny my_env_abc123
+        $ qbraid envs publish-deny my_env_abc123 --message "Missing documentation"
+    """
+    from qbraid_core.services.environments.client import EnvironmentManagerClient
+
+    console = Console()
+
+    def deny():
+        client = EnvironmentManagerClient()
+        return client.deny_publish(slug, message=message)
+
+    console.print(f"❌ Denying publish request: [bold]{slug}[/bold]")
+    if message:
+        console.print(f"   Reason: {message}")
+    console.print("")
+
+    try:
+        result = run_progress_task(
+            deny,
+            description="Denying publish request...",
+            error_message="Failed to deny"
+        )
+
+        console.print(f"[yellow]✅ Publish request denied.[/yellow]")
+        console.print(f"   Owner has been notified.")
+
+    except Exception as err:
+        error_msg = str(err)
+        if "permission" in error_msg.lower() or "admin" in error_msg.lower():
+            console.print(f"[red]❌ Admin access required.[/red]")
+        else:
+            console.print(f"[red]❌ Failed:[/red] {err}")
+        raise typer.Exit(1)
+
+
+@envs_app.command(name="share")
+def envs_share(
+    slug: str = typer.Argument(..., help="Environment slug to share"),
+    email: str = typer.Argument(..., help="Email of user to share with"),
+    read: bool = typer.Option(
+        True,
+        "--read/--no-read",
+        help="Grant read permission (view environment)"
+    ),
+    write: bool = typer.Option(
+        False,
+        "--write",
+        help="Grant write permission (modify environment)"
+    ),
+    execute: bool = typer.Option(
+        True,
+        "--execute/--no-execute",
+        help="Grant execute permission (install environment)"
+    ),
+):
+    """
+    Share an environment with another user.
+
+    By default, grants read and execute permissions (user can view and install).
+    Use --write to also allow modifications.
+
+    The environment must be uploaded first with 'qbraid envs upload'.
+
+    Examples:
+        $ qbraid envs share my_env_abc123 colleague@example.com
+        $ qbraid envs share my_env_abc123 collaborator@example.com --write
+        $ qbraid envs share my_env_abc123 viewer@example.com --no-execute
+    """
+    from qbraid_core.services.environments.client import EnvironmentManagerClient
+
+    console = Console()
+
+    # Build permissions list
+    permissions = []
+    if read:
+        permissions.append("read")
+    if write:
+        permissions.append("write")
+    if execute:
+        permissions.append("execute")
+
+    if not permissions:
+        console.print("[red]❌ Error:[/red] At least one permission must be granted.")
+        raise typer.Exit(1)
+
+    def share():
+        client = EnvironmentManagerClient()
+        return client.share_environment(
+            slug=slug,
+            target_type="user",
+            email=email,
+            permissions=permissions
+        )
+
+    console.print(f"🔗 Sharing environment: [bold]{slug}[/bold]")
+    console.print(f"   With: {email}")
+    console.print(f"   Permissions: {', '.join(permissions)}\n")
+
+    try:
+        result = run_progress_task(
+            share,
+            description="Sharing environment...",
+            error_message="Failed to share environment"
+        )
+
+        console.print(f"[green]✅ Environment shared successfully![/green]")
+        console.print(f"   {email} can now access [bold]{slug}[/bold]")
+
+        if execute:
+            console.print(f"\n💡 They can install with: [bold]qbraid envs install {slug}[/bold]")
+
+    except Exception as err:
+        error_msg = str(err)
+        if "not found" in error_msg.lower():
+            console.print(f"[red]❌ Environment not found.[/red] Make sure it's uploaded first.")
+        elif "owner" in error_msg.lower():
+            console.print(f"[red]❌ Only the owner can share this environment.[/red]")
+        else:
+            console.print(f"[red]❌ Failed to share:[/red] {err}")
+        raise typer.Exit(1)
+
+
+@envs_app.command(name="unshare")
+def envs_unshare(
+    slug: str = typer.Argument(..., help="Environment slug"),
+    email: str = typer.Argument(..., help="Email of user to revoke access from"),
+):
+    """
+    Revoke access to a shared environment.
+
+    This removes all permissions for the specified user.
+
+    Examples:
+        $ qbraid envs unshare my_env_abc123 former_colleague@example.com
+    """
+    from qbraid_core.services.environments.client import EnvironmentManagerClient
+
+    console = Console()
+
+    def revoke():
+        client = EnvironmentManagerClient()
+        # Revoke all permissions
+        return client.revoke_environment_access(
+            slug=slug,
+            target_type="user",
+            email=email,
+            permissions=["read", "write", "execute"]
+        )
+
+    console.print(f"🚫 Revoking access to: [bold]{slug}[/bold]")
+    console.print(f"   From: {email}\n")
+
+    try:
+        result = run_progress_task(
+            revoke,
+            description="Revoking access...",
+            error_message="Failed to revoke access"
+        )
+
+        console.print(f"[green]✅ Access revoked.[/green]")
+        console.print(f"   {email} no longer has access to [bold]{slug}[/bold]")
+
+    except Exception as err:
+        error_msg = str(err)
+        if "not found" in error_msg.lower():
+            console.print(f"[red]❌ Environment not found.[/red]")
+        elif "owner" in error_msg.lower():
+            console.print(f"[red]❌ Only the owner can modify sharing settings.[/red]")
+        else:
+            console.print(f"[red]❌ Failed to revoke:[/red] {err}")
+        raise typer.Exit(1)
+
+
+@envs_app.command(name="shared")
+def envs_shared(
+    slug: str = typer.Argument(..., help="Environment slug to check"),
+):
+    """
+    List users who have access to an environment.
+
+    Shows all users with read or write access to the specified environment.
+
+    Examples:
+        $ qbraid envs shared my_env_abc123
+    """
+    from qbraid_core.services.environments.client import EnvironmentManagerClient
+    from rich.table import Table
+
+    console = Console()
+
+    def get_shared():
+        client = EnvironmentManagerClient()
+        return client.get_environment_shared_with(slug)
+
+    try:
+        result = run_progress_task(
+            get_shared,
+            description="Fetching shared users...",
+            error_message="Failed to get shared users"
+        )
+
+        read_users = result.get("readAccessUsers", [])
+        write_users = result.get("writeAccessUsers", [])
+
+        console.print(f"\n📋 Sharing info for [bold]{slug}[/bold]\n")
+
+        if not read_users and not write_users:
+            console.print("[dim]This environment is not shared with anyone.[/dim]")
+            console.print(f"\n💡 Share with: [bold]qbraid envs share {slug} <email>[/bold]")
+            return
+
+        # Create table
+        table = Table(show_header=True, header_style="bold")
+        table.add_column("Email", style="cyan")
+        table.add_column("Name", style="dim")
+        table.add_column("Permissions", style="green")
+
+        # Track users we've already added (to avoid duplicates)
+        seen_emails = set()
+
+        # Add write users first (they have more permissions)
+        for user in write_users:
+            email = user.get("email", "N/A")
+            name = user.get("name", "")
+            if email not in seen_emails:
+                table.add_row(email, name, "read, write, execute")
+                seen_emails.add(email)
+
+        # Add read-only users
+        for user in read_users:
+            email = user.get("email", "N/A")
+            name = user.get("name", "")
+            if email not in seen_emails:
+                table.add_row(email, name, "read, execute")
+                seen_emails.add(email)
+
+        console.print(table)
+        console.print(f"\n[dim]Total: {len(seen_emails)} user(s)[/dim]")
+
+    except Exception as err:
+        error_msg = str(err)
+        if "not found" in error_msg.lower():
+            console.print(f"[red]❌ Environment not found.[/red]")
+        elif "owner" in error_msg.lower():
+            console.print(f"[red]❌ Only the owner can view sharing settings.[/red]")
+        else:
+            console.print(f"[red]❌ Failed to get shared users:[/red] {err}")
         raise typer.Exit(1)
 
 

{qbraid_cli-0.12.0a2 → qbraid_cli-0.12.0a3/qbraid_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qbraid-cli
-Version: 0.12.0a2
+Version: 0.12.0a3
 Summary: Command Line Interface for interacting with all parts of the qBraid platform.
 Author-email: qBraid Development Team <contact@qbraid.com>
 License-Expression: LicenseRef-Proprietary