aisc-cli 0.1.0__py3-none-any.whl

aisc/application/profile_service.py

@@ -0,0 +1,105 @@
+"""Profile service — read-only ``profile list`` and ``profile show``.
+
+Reads profiles from ~/.aisc/profiles.json with fallback to built-in definitions.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+# ---------------------------------------------------------------------------
+# Built-in profile definitions (fallback when profiles.json not found)
+# ---------------------------------------------------------------------------
+
+_BUILTIN_PROFILES: Dict[str, Dict[str, Any]] = {
+    "safe": {
+        "name": "safe",
+        "description": "Secure defaults (default profile)",
+        "dangerously_skip_permissions": False,
+    },
+    "unsafe": {
+        "name": "unsafe",
+        "description": "Explicit dangerous permissions for trusted projects",
+        "dangerously_skip_permissions": True,
+    },
+}
+
+
+# ---------------------------------------------------------------------------
+# Profile loading from .aisc/profiles.json
+# ---------------------------------------------------------------------------
+
+def _profiles_path(home: Optional[str] = None) -> Path:
+    """Return the path to profiles.json."""
+    home_path = Path(home).expanduser() if home is not None else Path.home()
+    return home_path / ".aisc" / "profiles.json"
+
+
+def _load_profiles(home: Optional[str] = None) -> Dict[str, Dict[str, Any]]:
+    """Load profiles from ~/.aisc/profiles.json, fallback to built-in."""
+    path = _profiles_path(home)
+    try:
+        if not path.is_file():
+            return _BUILTIN_PROFILES
+        raw = path.read_bytes()
+        data = json.loads(raw.decode("utf-8"))
+        if not isinstance(data, dict) or not isinstance(data.get("profiles"), dict):
+            return _BUILTIN_PROFILES
+        return data["profiles"]
+    except (OSError, ValueError, json.JSONDecodeError):
+        return _BUILTIN_PROFILES
+
+
+# ---------------------------------------------------------------------------
+# Result types
+# ---------------------------------------------------------------------------
+
+@dataclass
+class ProfileListResult:
+    data: Dict[str, Any] = field(default_factory=dict)
+    exit_code: int = 0
+    error_code: str = ""
+    error_message: str = ""
+
+
+@dataclass
+class ProfileShowResult:
+    data: Dict[str, Any] = field(default_factory=dict)
+    exit_code: int = 0
+    error_code: str = ""
+    error_message: str = ""
+
+
+# ---------------------------------------------------------------------------
+# Service functions
+# ---------------------------------------------------------------------------
+
+def run_profile_list(home: Optional[str] = None) -> ProfileListResult:
+    """Return all profiles as a list."""
+    profiles_dict = _load_profiles(home)
+    profiles: List[Dict[str, Any]] = []
+    for key in sorted(profiles_dict.keys()):
+        profiles.append(dict(profiles_dict[key]))
+
+    data: Dict[str, Any] = {"profiles": profiles}
+    return ProfileListResult(data=data, exit_code=0)
+
+
+def run_profile_show(name: str, home: Optional[str] = None) -> ProfileShowResult:
+    """Return a single profile by name."""
+    profiles_dict = _load_profiles(home)
+    profile = profiles_dict.get(name)
+    if profile is None:
+        return ProfileShowResult(
+            data={},
+            exit_code=1,
+            error_code="AISC_ERR_GENERAL",
+            error_message=f"Profile not found: {name}",
+        )
+
+    data = dict(profile)
+    return ProfileShowResult(data=data, exit_code=0)

aisc/application/provider.py

@@ -0,0 +1,92 @@
+"""Provider status application logic for Workbench Phase 0 S0.4.
+
+Implements the business logic behind ``aisc provider current``. Per
+docs/gui-planning/05-cli-gui-contract.md §七. Secret-free: the in-container
+``aisc-provider-inspect`` emits only metadata; this layer adds runtime_id and
+observed_at.
+"""
+
+from __future__ import annotations
+
+import datetime
+import json
+from typing import Any
+
+from aisc.application.runtime import resolve_running_container, validate_uuid_v4
+from aisc.domain.models import (
+    CliError,
+    ProviderStatus,
+    RuntimeErrorCode,
+    RuntimeExitCode,
+)
+
+_PROVIDER_INSPECT_PATH = "/usr/local/bin/aisc-provider-inspect"
+_AGENTS = ("claude", "codex")
+
+
+def _iso_now() -> str:
+    return datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def current_provider(
+    runtime_id: str,
+    agent: str,
+    executor: Any,
+    registry_root: Any,
+) -> ProviderStatus:
+    """Return the observable provider status for *agent* in runtime *runtime_id*.
+
+    Requires the runtime to be running; reads config in-container via
+    ``docker exec <ct> aisc-provider-inspect <agent>``. Never returns secrets.
+    """
+    if not validate_uuid_v4(runtime_id):
+        raise CliError(
+            message=f"Invalid runtime ID (must be UUID v4): {runtime_id}",
+            exit_code=RuntimeExitCode.INVALID_RUNTIME_ID,
+            error_code=RuntimeErrorCode.INVALID_RUNTIME_ID,
+        )
+    if agent not in _AGENTS:
+        raise CliError(
+            message=f"Invalid agent (must be one of {', '.join(_AGENTS)}): {agent}",
+            exit_code=RuntimeExitCode.USAGE_ERROR,
+            error_code=RuntimeErrorCode.INVALID_AGENT,
+        )
+
+    container_name = resolve_running_container(runtime_id, executor, registry_root)
+
+    result = executor.run_captured(
+        ["exec", container_name, _PROVIDER_INSPECT_PATH, agent],
+        timeout=15.0,
+    )
+    if result.exit_code != 0:
+        raise CliError(
+            message=f"Provider status inspection failed: "
+                    f"{(result.stderr or '').strip()[:200]}",
+            exit_code=RuntimeExitCode.PROVIDER_STATUS_FAILED,
+            error_code=RuntimeErrorCode.PROVIDER_STATUS_FAILED,
+        )
+
+    try:
+        data = json.loads(result.stdout.strip())
+    except json.JSONDecodeError as exc:
+        raise CliError(
+            message=f"Invalid provider status output: {exc}",
+            exit_code=RuntimeExitCode.PROVIDER_STATUS_FAILED,
+            error_code=RuntimeErrorCode.PROVIDER_STATUS_FAILED,
+        )
+    if not isinstance(data, dict):
+        raise CliError(
+            message="Provider status output is not a JSON object",
+            exit_code=RuntimeExitCode.PROVIDER_STATUS_FAILED,
+            error_code=RuntimeErrorCode.PROVIDER_STATUS_FAILED,
+        )
+
+    return ProviderStatus(
+        runtime_id=runtime_id,
+        agent=agent,
+        provider_id=str(data.get("provider_id", "")),
+        provider_name=str(data.get("provider_name", "")),
+        route_mode=str(data.get("route_mode", "unknown")) or "unknown",
+        auth_status=str(data.get("auth_status", "unknown")) or "unknown",
+        observed_at=_iso_now(),
+    )

aisc/application/repair.py

@@ -0,0 +1,387 @@
+"""Environment repair — automatic installation of missing dependencies.
+
+Provides interactive installation for Docker and other dependencies when
+aisc doctor detects missing components.
+"""
+
+from __future__ import annotations
+
+import os
+import platform
+import shutil
+import sys
+from pathlib import Path
+from typing import Optional, Tuple
+
+from aisc.adapters.system import ProcessRunner, RealProcessRunner
+from aisc.domain.models import ProcessResult
+
+
+def _run_install_command(
+    runner: ProcessRunner,
+    argv: list[str],
+    timeout: float,
+) -> ProcessResult:
+    """Run installers on the terminal when the runner supports streaming."""
+    run_streaming = getattr(runner, "run_streaming", None)
+    if callable(run_streaming):
+        return run_streaming(argv, timeout=timeout)
+    return runner.run(argv, timeout=timeout)
+
+
+def _find_brew_executable() -> Optional[str]:
+    discovered = shutil.which("brew")
+    if discovered:
+        return discovered
+    for candidate in ("/opt/homebrew/bin/brew", "/usr/local/bin/brew"):
+        if Path(candidate).is_file():
+            return candidate
+    return None
+
+
+def detect_platform() -> Tuple[str, str]:
+    """Detect OS platform and architecture.
+
+    Returns:
+        (platform, arch) where platform is 'linux', 'darwin', or 'windows'
+        and arch is 'x86_64' or 'arm64'
+    """
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+
+    # Normalize platform name
+    if system == "darwin":
+        plat = "darwin"
+    elif system == "linux":
+        plat = "linux"
+    elif system in ("windows", "cygwin", "msys"):
+        plat = "windows"
+    else:
+        plat = "unknown"
+
+    # Normalize architecture
+    if machine in ("x86_64", "amd64"):
+        arch = "x86_64"
+    elif machine in ("arm64", "aarch64"):
+        arch = "arm64"
+    else:
+        arch = "unknown"
+
+    return plat, arch
+
+
+def can_install_docker(runner: Optional[ProcessRunner] = None) -> Tuple[bool, str]:
+    """Check if Docker can be automatically installed on this platform.
+
+    Returns:
+        (can_install, method) where method is the installation tool name
+    """
+    if runner is None:
+        runner = RealProcessRunner()
+
+    plat, _ = detect_platform()
+
+    if plat == "linux":
+        # Check for curl (needed for get.docker.com)
+        if shutil.which("curl"):
+            return True, "get.docker.com"
+        return False, "curl not found"
+
+    elif plat == "darwin":
+        # Check for Homebrew
+        if shutil.which("brew"):
+            return True, "homebrew"
+        return True, "homebrew-install-first"
+
+    elif plat == "windows":
+        # Check for winget
+        if shutil.which("winget"):
+            return True, "winget"
+        return False, "winget not found"
+
+    return False, "unsupported platform"
+
+
+def get_docker_install_prompt(method: str) -> str:
+    """Get user-facing prompt for Docker installation.
+
+    Args:
+        method: Installation method from can_install_docker()
+
+    Returns:
+        Prompt message explaining what will be done
+    """
+    if method == "get.docker.com":
+        return """
+Docker is not installed. AISC can automatically install it using the
+official Docker installation script.
+
+This will:
+  • Download and run https://get.docker.com
+  • Install Docker Engine and CLI tools
+  • Add your user to the 'docker' group (requires sudo)
+  • You may need to log out and log back in for group changes to take effect
+
+Do you want to install Docker now?"""
+
+    elif method == "homebrew":
+        return """
+Docker is not installed. AISC can automatically install Docker Desktop
+using Homebrew.
+
+This will:
+  • Run: brew install --cask docker
+  • Download and install Docker Desktop (~500MB)
+  • Automatically start Docker Desktop
+  • You may need to accept system permissions
+
+Do you want to install Docker now?"""
+
+    elif method == "homebrew-install-first":
+        return """
+Docker is not installed. AISC can install it via Homebrew, but Homebrew
+is not currently installed.
+
+This will:
+  • First install Homebrew (the macOS package manager)
+  • Then install Docker Desktop via: brew install --cask docker
+  • You will see prompts for your password and admin approval
+
+Do you want to proceed?"""
+
+    elif method == "winget":
+        return """
+Docker is not installed. AISC can automatically install Docker Desktop
+using Windows Package Manager (winget).
+
+This will:
+  • Run: winget install Docker.DockerDesktop --silent
+  • Download and install Docker Desktop (~500MB)
+  • Require administrator privileges (UAC prompt)
+  • Require logging out and back in (or restarting) after installation
+
+Do you want to install Docker now?"""
+
+    return "Unknown installation method"
+
+
+def install_docker_linux(runner: ProcessRunner) -> Tuple[bool, str]:
+    """Install Docker on Linux using get.docker.com.
+
+    Returns:
+        (success, message)
+    """
+    print("Downloading Docker installation script...")
+
+    # Download and run the official Docker install script
+    result = _run_install_command(
+        runner,
+        ["sh", "-c", "curl -fsSL https://get.docker.com | sudo sh"],
+        300.0,
+    )
+
+    if result.exit_code != 0:
+        return False, f"Docker installation failed: {result.stderr or result.stdout}"
+
+    print("Docker installed successfully!")
+    print("\nConfiguring user permissions...")
+
+    # Add user to docker group
+    username = os.getenv("USER", os.getenv("USERNAME", ""))
+    if username:
+        perm_result = runner.run(
+            ["sudo", "usermod", "-aG", "docker", username],
+            timeout=10.0,
+        )
+        if perm_result.exit_code == 0:
+            return True, f"""
+Docker installed successfully!
+
+IMPORTANT: You need to log out and log back in for group permissions to take effect.
+
+After logging back in, run 'aisc doctor' to verify the installation.
+"""
+        else:
+            return True, """
+Docker installed, but failed to configure user permissions.
+You may need to manually run: sudo usermod -aG docker $USER
+Then log out and log back in.
+"""
+
+    return True, "Docker installed successfully!"
+
+
+def install_docker_macos(runner: ProcessRunner, install_brew_first: bool) -> Tuple[bool, str]:
+    """Install Docker on macOS using Homebrew.
+
+    Args:
+        install_brew_first: Whether to install Homebrew first
+
+    Returns:
+        (success, message)
+    """
+    if install_brew_first:
+        print("Installing Homebrew first...")
+        brew_result = _run_install_command(
+            runner,
+            [
+                "/bin/bash", "-c",
+                "curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh | /bin/bash",
+            ],
+            300.0,
+        )
+        if brew_result.exit_code != 0:
+            return False, "Failed to install Homebrew"
+        print("Homebrew installed successfully!")
+
+    brew_executable = _find_brew_executable()
+    if not brew_executable:
+        return False, "Homebrew installation completed, but brew was not found"
+
+    brew_dir = os.path.dirname(brew_executable)
+    path_entries = os.environ.get("PATH", "").split(os.pathsep)
+    if brew_dir not in path_entries:
+        os.environ["PATH"] = os.pathsep.join([brew_dir, *path_entries])
+
+    print("Installing Docker Desktop via Homebrew...")
+    print("This may take several minutes to download (~500MB)...")
+
+    result = _run_install_command(
+        runner,
+        [brew_executable, "install", "--cask", "docker"],
+        600.0,
+    )
+
+    if result.exit_code != 0:
+        return False, f"Docker installation failed: {result.stderr or result.stdout}"
+
+    print("Docker Desktop installed successfully!")
+    print("Starting Docker Desktop...")
+
+    # Try to start Docker Desktop
+    start_result = runner.run(
+        ["open", "-a", "Docker"],
+        timeout=10.0,
+    )
+
+    if start_result.exit_code == 0:
+        return True, """
+Docker Desktop installed and started successfully!
+
+Docker Desktop is launching in the background. This may take a minute.
+Please accept any system permission prompts and the Docker service agreement.
+
+Run 'aisc doctor' in a minute to verify Docker is running.
+"""
+    else:
+        return True, """
+Docker Desktop installed, but failed to start automatically.
+Please manually open Docker Desktop from your Applications folder.
+
+After Docker Desktop is running, run 'aisc doctor' to verify.
+"""
+
+
+def install_docker_windows(runner: ProcessRunner) -> Tuple[bool, str]:
+    """Install Docker on Windows using winget.
+
+    Returns:
+        (success, message)
+    """
+    print("Installing Docker Desktop via winget...")
+    print("You will see a UAC (User Account Control) prompt - please accept it.")
+    print("This may take several minutes to download (~500MB)...")
+
+    result = _run_install_command(
+        runner,
+        [
+            "winget", "install", "Docker.DockerDesktop",
+            "--silent",
+            "--accept-source-agreements",
+            "--accept-package-agreements",
+        ],
+        600.0,
+    )
+
+    if result.exit_code != 0:
+        return False, f"Docker installation failed: {result.stderr or result.stdout}"
+
+    return True, """
+Docker Desktop installed successfully!
+
+IMPORTANT: You need to log out and log back in (or restart your computer)
+for the installation to complete.
+
+After logging back in:
+1. Start Docker Desktop from the Start menu
+2. Accept the service agreement
+3. Run 'aisc doctor' to verify the installation
+"""
+
+
+def install_docker_interactive(runner: Optional[ProcessRunner] = None) -> bool:
+    """Interactively install Docker if missing.
+
+    Returns:
+        True if installation was successful (or user declined)
+        False if installation failed
+    """
+    if runner is None:
+        runner = RealProcessRunner()
+
+    can_install, method = can_install_docker(runner)
+
+    if not can_install:
+        print(f"\nCannot automatically install Docker: {method}", file=sys.stderr)
+        print("Please install Docker manually:", file=sys.stderr)
+        print("  https://docs.docker.com/get-docker/", file=sys.stderr)
+        return True  # Not a failure, just unsupported
+
+    # Show installation prompt
+    prompt = get_docker_install_prompt(method)
+    print(prompt)
+
+    try:
+        response = input("\nProceed with installation? [y/N]: ").strip().lower()
+    except (EOFError, KeyboardInterrupt):
+        print("\nInstallation cancelled.")
+        return True
+
+    if response not in ("y", "yes"):
+        print("Installation cancelled. You can install Docker manually:")
+        print("  https://docs.docker.com/get-docker/")
+        return True
+
+    # Perform installation
+    print("\nStarting Docker installation...")
+
+    plat, _ = detect_platform()
+    success = False
+    message = ""
+
+    try:
+        if plat == "linux" and method == "get.docker.com":
+            success, message = install_docker_linux(runner)
+        elif plat == "darwin":
+            install_brew = (method == "homebrew-install-first")
+            success, message = install_docker_macos(runner, install_brew)
+        elif plat == "windows" and method == "winget":
+            success, message = install_docker_windows(runner)
+        else:
+            print(f"Unsupported platform/method: {plat}/{method}", file=sys.stderr)
+            return False
+    except Exception as exc:
+        print(f"\nInstallation failed with error: {exc}", file=sys.stderr)
+        return False
+
+    # Show result
+    print("\n" + "=" * 60)
+    if success:
+        print("✓ Installation completed")
+        print(message)
+    else:
+        print("✗ Installation failed")
+        print(message, file=sys.stderr)
+    print("=" * 60)
+
+    return success