scc-cli 1.5.3__py3-none-any.whl

scc_cli/cli.py

@@ -0,0 +1,311 @@
+#!/usr/bin/env python3
+"""
+SCC - Sandboxed Claude CLI
+
+A command-line tool for safely running Claude Code in Docker sandboxes
+with team-specific configurations and worktree management.
+
+This module serves as the thin orchestrator that composes commands from:
+- commands/launch.py: Start command and interactive mode
+- commands/worktree.py: Worktree, session, and container management
+- commands/config.py: Teams, setup, and configuration commands
+- commands/admin.py: Doctor, update, statusline, and stats commands
+"""
+
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as get_installed_version
+
+import typer
+
+from .cli_common import console, state
+from .commands.admin import (
+    doctor_cmd,
+    stats_app,
+    status_cmd,
+    statusline_cmd,
+    update_cmd,
+)
+from .commands.audit import audit_app
+from .commands.config import (
+    config_cmd,
+    setup_cmd,
+)
+from .commands.exceptions import exceptions_app, unblock_cmd
+from .commands.init import init_cmd
+
+# Import command functions from domain modules
+from .commands.launch import start
+from .commands.org import org_app
+from .commands.support import support_app
+from .commands.team import team_app
+from .commands.worktree import (
+    container_app,
+    context_app,
+    list_cmd,
+    prune_cmd,
+    session_app,
+    sessions_cmd,
+    stop_cmd,
+    worktree_app,
+)
+
+# ─────────────────────────────────────────────────────────────────────────────
+# App Configuration
+# ─────────────────────────────────────────────────────────────────────────────
+
+app = typer.Typer(
+    name="scc-cli",
+    help="Safely run Claude Code with team configurations and worktree management.",
+    no_args_is_help=False,
+    rich_markup_mode="rich",
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Global Callback (--debug flag)
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+@app.callback(invoke_without_command=True)
+def main_callback(
+    ctx: typer.Context,
+    debug: bool = typer.Option(
+        False,
+        "--debug",
+        help="Show detailed error information for troubleshooting.",
+        is_eager=True,
+    ),
+    version: bool = typer.Option(
+        False,
+        "--version",
+        "-v",
+        help="Show version and exit.",
+        is_eager=True,
+    ),
+    interactive: bool = typer.Option(
+        False,
+        "-i",
+        "--interactive",
+        help="Force interactive workspace picker (shortcut for 'scc start -i').",
+    ),
+) -> None:
+    """
+    [bold cyan]SCC[/bold cyan] - Sandboxed Claude CLI
+
+    Safely run Claude Code in Docker sandboxes with team configurations.
+    """
+    state.debug = debug
+
+    if version:
+        from .ui.branding import get_version_header
+
+        try:
+            pkg_version = get_installed_version("scc-cli")
+        except PackageNotFoundError:
+            pkg_version = "unknown"
+        console.print(get_version_header(pkg_version))
+        raise typer.Exit()
+
+    # If no command provided and not showing version, use context-aware routing
+    if ctx.invoked_subcommand is None:
+        from pathlib import Path
+
+        from rich.prompt import Prompt
+
+        from . import config as scc_config
+        from . import setup as scc_setup
+        from .services.workspace import resolve_launch_context
+        from .ui.gate import is_interactive_allowed
+
+        # Use strong-signal resolver (git or .scc.yaml) for parity with 'scc start'
+        # Weak markers (package.json, etc.) are NOT used for auto-launch
+        cwd = Path.cwd()
+        result = resolve_launch_context(cwd, workspace_arg=None)
+        workspace_detected = result is not None and result.is_auto_eligible()
+
+        if is_interactive_allowed():
+            # If no org is configured and standalone isn't explicit, offer setup
+            user_cfg = scc_config.load_user_config()
+            org_source = user_cfg.get("organization_source") or {}
+            has_org = bool(org_source.get("url"))
+            if not has_org and not user_cfg.get("standalone"):
+                choice = Prompt.ask(
+                    "[yellow]No organization configured.[/yellow] Choose setup mode",
+                    choices=["setup", "standalone", "quit"],
+                    default="setup",
+                )
+                if choice == "setup":
+                    if not scc_setup.run_setup_wizard(console):
+                        raise typer.Exit(0)
+                elif choice == "standalone":
+                    user_cfg["standalone"] = True
+                    scc_config.save_user_config(user_cfg)
+                else:
+                    raise typer.Exit(0)
+
+                # Offer to start immediately after setup/standalone choice
+                start_now = Prompt.ask(
+                    "[cyan]Start a session now?[/cyan]",
+                    choices=["yes", "no"],
+                    default="yes",
+                )
+                if start_now == "yes":
+                    ctx.invoke(
+                        start,
+                        workspace=str(cwd) if workspace_detected else None,
+                        team=None,
+                        session_name=None,
+                        resume=False,
+                        select=False,
+                        continue_session=False,
+                        worktree_name=None,
+                        fresh=False,
+                        install_deps=False,
+                        offline=False,
+                        standalone=False,
+                        dry_run=False,
+                        json_output=False,
+                        pretty=False,
+                    )
+                    return
+
+            if interactive:
+                # -i flag: force interactive workspace picker via start -i
+                ctx.invoke(
+                    start,
+                    workspace=None,
+                    team=None,
+                    session_name=None,
+                    resume=False,
+                    select=False,
+                    continue_session=False,
+                    worktree_name=None,
+                    fresh=False,
+                    install_deps=False,
+                    offline=False,
+                    standalone=False,
+                    dry_run=False,
+                    json_output=False,
+                    pretty=False,
+                )
+            elif workspace_detected:
+                # Strong signal found (git repo or .scc.yaml) → use smart start flow
+                # This shows Quick Resume (if sessions exist) or launches immediately
+                ctx.invoke(
+                    start,
+                    workspace=str(cwd),
+                    team=None,
+                    session_name=None,
+                    resume=False,
+                    select=False,
+                    continue_session=False,
+                    worktree_name=None,
+                    fresh=False,
+                    install_deps=False,
+                    offline=False,
+                    standalone=False,
+                    dry_run=False,
+                    json_output=False,
+                    pretty=False,
+                )
+            else:
+                # No strong signal (not in git repo, no .scc.yaml) → show dashboard
+                from .ui.dashboard import run_dashboard
+
+                run_dashboard()
+        else:
+            # Non-interactive - invoke start with defaults (will fail F1/F2 if no signal)
+            # NOTE: Must pass ALL defaults explicitly - ctx.invoke() doesn't resolve
+            # typer.Argument/Option defaults, it passes raw ArgumentInfo/OptionInfo
+            ctx.invoke(
+                start,
+                workspace=str(cwd) if workspace_detected else None,
+                team=None,
+                session_name=None,
+                resume=False,
+                select=False,
+                continue_session=False,
+                worktree_name=None,
+                fresh=False,
+                install_deps=False,
+                offline=False,
+                standalone=False,
+                dry_run=False,
+                json_output=False,
+                pretty=False,
+            )
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Help Panel Group Names
+# ─────────────────────────────────────────────────────────────────────────────
+
+PANEL_SESSION = "Session Management"
+PANEL_WORKSPACE = "Workspace"
+PANEL_CONFIG = "Configuration"
+PANEL_ADMIN = "Administration"
+PANEL_GOVERNANCE = "Governance"
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Register Commands from Domain Modules
+# ─────────────────────────────────────────────────────────────────────────────
+
+# Launch commands
+app.command(rich_help_panel=PANEL_SESSION)(start)
+
+# Worktree command group
+app.add_typer(worktree_app, name="worktree", rich_help_panel=PANEL_WORKSPACE)
+
+# Session and container commands
+app.command(name="sessions", rich_help_panel=PANEL_SESSION)(sessions_cmd)
+app.command(name="list", rich_help_panel=PANEL_SESSION)(list_cmd)
+app.command(name="stop", rich_help_panel=PANEL_SESSION)(stop_cmd)
+app.command(name="prune", rich_help_panel=PANEL_SESSION)(prune_cmd)
+
+# Configuration commands
+app.add_typer(team_app, name="team", rich_help_panel=PANEL_CONFIG)
+app.command(name="setup", rich_help_panel=PANEL_CONFIG)(setup_cmd)
+app.command(name="config", rich_help_panel=PANEL_CONFIG)(config_cmd)
+app.command(name="init", rich_help_panel=PANEL_CONFIG)(init_cmd)
+
+# Admin commands
+app.command(name="doctor", rich_help_panel=PANEL_ADMIN)(doctor_cmd)
+app.command(name="update", rich_help_panel=PANEL_ADMIN)(update_cmd)
+app.command(name="status", rich_help_panel=PANEL_ADMIN)(status_cmd)
+app.command(name="statusline", rich_help_panel=PANEL_ADMIN)(statusline_cmd)
+
+# Add stats sub-app
+app.add_typer(stats_app, name="stats", rich_help_panel=PANEL_ADMIN)
+
+# Exception management commands
+app.add_typer(exceptions_app, name="exceptions", rich_help_panel=PANEL_GOVERNANCE)
+app.command(name="unblock", rich_help_panel=PANEL_GOVERNANCE)(unblock_cmd)
+
+# Audit commands
+app.add_typer(audit_app, name="audit", rich_help_panel=PANEL_GOVERNANCE)
+
+# Support commands
+app.add_typer(support_app, name="support", rich_help_panel=PANEL_GOVERNANCE)
+
+# Org admin commands
+app.add_typer(org_app, name="org", rich_help_panel=PANEL_GOVERNANCE)
+
+# Symmetric alias apps (Phase 8)
+app.add_typer(session_app, name="session", rich_help_panel=PANEL_WORKSPACE)
+app.add_typer(container_app, name="container", rich_help_panel=PANEL_WORKSPACE)
+app.add_typer(context_app, name="context", rich_help_panel=PANEL_WORKSPACE)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Entry Point
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def main() -> None:
+    """Entry point for the CLI."""
+    app()
+
+
+if __name__ == "__main__":
+    main()

scc_cli/cli_common.py

@@ -0,0 +1,190 @@
+"""
+CLI Common Utilities.
+
+Shared utilities, constants, and decorators used across all CLI modules.
+This module is extracted to prevent circular imports and enable clean composition.
+"""
+
+from collections.abc import Callable
+from functools import wraps
+from typing import Any, TypeVar, cast
+
+import typer
+from rich import box
+from rich.console import Console
+from rich.table import Table
+
+from .core.errors import SCCError
+from .core.exit_codes import EXIT_CANCELLED
+from .output_mode import is_json_command_mode
+from .panels import create_warning_panel
+from .ui.prompts import render_error
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Display Constants
+# ─────────────────────────────────────────────────────────────────────────────
+
+# Maximum length for displaying file paths before truncation
+MAX_DISPLAY_PATH_LENGTH = 50
+# Characters to keep when truncating (MAX - 3 for "...")
+PATH_TRUNCATE_LENGTH = 47
+# Terminal width threshold for wide mode tables
+WIDE_MODE_THRESHOLD = 110
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Shared Console and State
+# ─────────────────────────────────────────────────────────────────────────────
+
+console = Console()
+err_console = Console(stderr=True)
+
+
+class AppState:
+    """Global application state for CLI flags."""
+
+    debug: bool = False
+
+
+state = AppState()
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Error Boundary Decorator
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def handle_errors(func: F) -> F:
+    """Catch SCCError exceptions and render user-friendly error output.
+
+    Wrap CLI command functions to provide consistent error handling:
+    - SCCError: Render with render_error and exit with error's exit_code
+    - KeyboardInterrupt: Print cancellation message and exit 130
+    - Other exceptions: Show warning panel (or full traceback with --debug)
+
+    JSON Mode: This is the SINGLE LOCATION for JSON error envelope output.
+    All errors in JSON mode are handled here to ensure consistency.
+
+    Args:
+        func: The CLI command function to wrap.
+
+    Returns:
+        Wrapped function with error handling.
+    """
+
+    @wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        try:
+            return func(*args, **kwargs)
+        except SCCError as e:
+            if is_json_command_mode():
+                # JSON mode: emit structured error envelope to stdout
+                from .core.exit_codes import get_exit_code_for_exception
+                from .json_output import build_error_envelope
+                from .output_mode import print_json
+
+                envelope = build_error_envelope(e)
+                print_json(envelope)
+                raise typer.Exit(get_exit_code_for_exception(e))
+            # Human mode: use stderr for errors (stdout purity for shell wrappers)
+            render_error(err_console, e, debug=state.debug)
+            raise typer.Exit(e.exit_code)
+        except KeyboardInterrupt:
+            if is_json_command_mode():
+                # JSON mode: emit cancellation envelope
+                from .json_output import build_error_envelope
+                from .output_mode import print_json
+
+                # Create a pseudo-exception for the envelope
+                cancel_exc = Exception("Operation cancelled by user")
+                envelope = build_error_envelope(cancel_exc)
+                print_json(envelope)
+                raise typer.Exit(EXIT_CANCELLED)
+            # Human mode: use stderr
+            err_console.print("\n[dim]Operation cancelled.[/dim]")
+            raise typer.Exit(EXIT_CANCELLED)
+        except (typer.Exit, SystemExit):
+            # Let typer exits pass through
+            raise
+        except Exception as e:
+            if is_json_command_mode():
+                # JSON mode: emit structured error envelope for unexpected errors
+                from .core.exit_codes import EXIT_INTERNAL
+                from .json_output import build_error_envelope
+                from .output_mode import print_json
+
+                envelope = build_error_envelope(e)
+                print_json(envelope)
+                raise typer.Exit(EXIT_INTERNAL)
+            # Human mode: unexpected errors to stderr
+            if state.debug:
+                err_console.print_exception()
+            else:
+                err_console.print(
+                    create_warning_panel(
+                        "Unexpected Error",
+                        str(e),
+                        "Run with --debug for full traceback",
+                    )
+                )
+            raise typer.Exit(5)
+
+    return cast(F, wrapper)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# UI Helpers (Consistent Aesthetic)
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def render_responsive_table(
+    title: str,
+    columns: list[tuple[str, str]],  # (header, style)
+    rows: list[list[str]],
+    wide_columns: list[tuple[str, str]] | None = None,  # Extra columns for wide mode
+) -> None:
+    """Render a table that adapts to terminal width.
+
+    Display base columns on narrow terminals, adding extra columns when
+    terminal width exceeds WIDE_MODE_THRESHOLD.
+
+    Args:
+        title: Table title displayed above the table.
+        columns: Base columns as list of (header, style) tuples.
+        rows: Data rows where each row contains values for all columns
+            (base + wide). Extra values are ignored on narrow terminals.
+        wide_columns: Additional columns shown only on wide terminals.
+    """
+    width = console.width
+    wide_mode = width >= WIDE_MODE_THRESHOLD
+
+    table = Table(
+        title=f"[bold cyan]{title}[/bold cyan]",
+        box=box.ROUNDED,
+        header_style="bold cyan",
+        expand=True,
+        show_lines=False,
+    )
+
+    # Add base columns
+    for header, style in columns:
+        table.add_column(header, style=style)
+
+    # Add extra columns in wide mode
+    if wide_mode and wide_columns:
+        for header, style in wide_columns:
+            table.add_column(header, style=style)
+
+    # Add rows
+    for row in rows:
+        if wide_mode and wide_columns:
+            table.add_row(*row)
+        else:
+            # Truncate to base columns only
+            table.add_row(*row[: len(columns)])
+
+    console.print()
+    console.print(table)
+    console.print()