ltcai 11.5.2 → 11.7.0

package/latticeai/setup/wizard/detect.py

@@ -1,302 +0,0 @@
-"""Hardware, OS, toolchain and API-key detection for the setup wizard.
-
-Everything the recommender needs to know about *this* machine: chip, CPU
-features, RAM, free disk, GPU/CUDA/WSL, which CLIs are on PATH, whether MLX
-imports, and which provider keys are in the environment. Every probe is
-best-effort — a failed probe answers "unknown", never raises.
-"""
-
-from __future__ import annotations
-
-import os
-import platform
-import re
-import shutil
-import subprocess
-from pathlib import Path
-from typing import Any, Dict, List
-
-from latticeai.core.quiet import quiet
-from latticeai.services.setup_detection import (
-    detect_cuda,
-    detect_tools,
-    detect_wsl_from_text,
-    parse_windows_cpu_info,
-    windows_processor_features,
-)
-from latticeai.services.setup_detection import (
-    parse_windows_video_controllers as _parse_windows_video_controllers,
-)
-from latticeai.setup.wizard.paths import (
-    _component_detail,
-    _module_available,
-    _which_any,
-    repair_path_for,
-)
-
-
-def _cmd(args: List[str], timeout: int = 10) -> str:
-    try:
-        r = subprocess.run(args, capture_output=True, text=True, timeout=timeout, check=False)
-        return (r.stdout or r.stderr or "").strip()
-    except Exception:
-        return ""
-
-# ── Environment Detection ─────────────────────────────────────────────────────
-
-def _detect_chip() -> Dict[str, Any]:
-    arch = platform.machine()
-    is_apple = arch == "arm64" and platform.system() == "Darwin"
-    name = "Unknown CPU"
-    gen: Any = None
-
-    if is_apple:
-        profiler = _cmd(["system_profiler", "SPHardwareDataType"], timeout=8)
-        m = re.search(r"Chip:\s+(Apple M\S+)", profiler)
-        name = m.group(1) if m else "Apple Silicon"
-        gm = re.search(r"M(\d+)", name)
-        gen = int(gm.group(1)) if gm else 1
-    else:
-        brand = ""
-        if platform.system() == "Darwin":
-            brand = _cmd(["sysctl", "-n", "machdep.cpu.brand_string"])
-        elif platform.system() == "Windows":
-            raw = _cmd(["wmic", "cpu", "get", "Name", "/value"], timeout=5)
-            if "Name=" in raw:
-                brand = raw.split("Name=", 1)[-1].splitlines()[0].strip()
-        elif platform.system() == "Linux":
-            try:
-                for line in Path("/proc/cpuinfo").read_text(encoding="utf-8", errors="replace").splitlines():
-                    if line.lower().startswith("model name"):
-                        brand = line.split(":", 1)[-1].strip()
-                        break
-            except Exception:
-                quiet()
-        name = brand or platform.processor() or "Unknown CPU"
-
-    return {"name": name, "arch": arch, "is_apple_silicon": is_apple, "gen": gen}
-
-
-def _detect_cpu() -> Dict[str, Any]:
-    flags: List[str] = []
-    physical_cores = os.cpu_count() or 0
-    logical_cores = os.cpu_count() or 0
-    model = _detect_chip()["name"]
-    if platform.system() == "Darwin":
-        flags = [item.lower() for item in _cmd(["sysctl", "-n", "machdep.cpu.features"], timeout=5).split()]
-        try:
-            physical_cores = int(_cmd(["sysctl", "-n", "hw.physicalcpu"], timeout=5) or physical_cores)
-            logical_cores = int(_cmd(["sysctl", "-n", "hw.logicalcpu"], timeout=5) or logical_cores)
-        except ValueError:
-            quiet()
-    elif platform.system() == "Linux":
-        try:
-            text = Path("/proc/cpuinfo").read_text(encoding="utf-8", errors="replace")
-            for line in text.splitlines():
-                if line.lower().startswith(("flags", "features")):
-                    flags = line.split(":", 1)[-1].strip().lower().split()
-                    break
-        except Exception:
-            quiet()
-    elif platform.system() == "Windows":
-        raw = _cmd(["wmic", "cpu", "get", "Name,NumberOfCores,NumberOfLogicalProcessors", "/format:list"], timeout=5)
-        model, physical_cores, logical_cores = parse_windows_cpu_info(
-            raw, model=model, physical_cores=physical_cores, logical_cores=logical_cores,
-        )
-        flags.extend(windows_processor_features())
-    interesting = {"avx", "avx2", "avx512f", "fma", "neon", "sse4_2"}
-    if platform.system() == "Windows":
-        interesting.update({"sse", "sse2", "sse3", "rdrand"})
-    return {
-        "model": model,
-        "physical_cores": physical_cores,
-        "logical_cores": logical_cores,
-        "instructions": sorted({flag for flag in flags if flag in interesting}),
-    }
-
-def _detect_ram_gb() -> float:
-    if platform.system() == "Windows":
-        raw = _cmd(["wmic", "ComputerSystem", "get", "TotalPhysicalMemory", "/format:list"], timeout=5)
-        for line in raw.splitlines():
-            if line.startswith("TotalPhysicalMemory="):
-                try:
-                    return round(int(line.split("=", 1)[-1].strip()) / 1_073_741_824, 1)
-                except ValueError:
-                    break
-    raw = _cmd(["sysctl", "-n", "hw.memsize"])
-    if raw:
-        try:
-            return round(int(raw) / 1_073_741_824, 1)
-        except ValueError:
-            quiet()
-    if platform.system() == "Darwin":
-        profiler = _cmd(["system_profiler", "SPHardwareDataType"], timeout=8)
-        m = re.search(r"Memory:\s+([\d.]+)\s*(TB|GB|MB)", profiler, re.IGNORECASE)
-        if m:
-            value = float(m.group(1))
-            unit = m.group(2).lower()
-            if unit == "tb":
-                return round(value * 1024, 1)
-            if unit == "gb":
-                return round(value, 1)
-            return round(value / 1024, 1)
-        hostinfo = _cmd(["hostinfo"], timeout=5)
-        m = re.search(r"Primary memory available:\s+([\d.]+)\s+gigabytes", hostinfo, re.IGNORECASE)
-        if m:
-            return round(float(m.group(1)), 1)
-    try:
-        with open("/proc/meminfo") as f:
-            for line in f:
-                if line.startswith("MemTotal:"):
-                    return round(int(line.split()[1]) / 1_048_576, 1)
-    except Exception:
-        quiet()
-    return 0.0
-
-def _detect_disk_free_gb() -> float:
-    try:
-        path = "C:\\" if platform.system() == "Windows" else "/"
-        return round(shutil.disk_usage(path).free / 1_073_741_824, 1)
-    except Exception:
-        return 0.0
-
-
-def _detect_gpu() -> Dict[str, Any]:
-    devices: List[Dict[str, Any]] = []
-    nvidia_smi = _which_any("nvidia-smi")
-    if nvidia_smi:
-        info = _cmd([nvidia_smi, "--query-gpu=name,memory.total", "--format=csv,noheader,nounits"], timeout=8)
-        for line in [item.strip() for item in info.splitlines() if item.strip()]:
-            try:
-                name, mem = [part.strip() for part in line.split(",", 1)]
-                devices.append({"vendor": "nvidia", "name": name, "vram_mb": int(float(mem)), "backend": "cuda"})
-            except Exception:
-                quiet()
-                continue
-
-    if platform.system() == "Windows":
-        shell = _which_any("powershell") or _which_any("pwsh")
-        raw = ""
-        if shell:
-            raw = _cmd([
-                shell, "-NoProfile", "-Command",
-                "Get-CimInstance Win32_VideoController | Select-Object Name,AdapterRAM | ConvertTo-Json -Compress",
-            ], timeout=8)
-        if not raw:
-            raw = _cmd(["wmic", "path", "win32_VideoController", "get", "Name,AdapterRAM", "/format:list"], timeout=8)
-        for item in _parse_windows_video_controllers(raw):
-            if any(existing.get("name") == item["name"] for existing in devices):
-                continue
-            low = item["name"].lower()
-            vendor, backend = "unknown", "cpu"
-            if "nvidia" in low or "geforce" in low or "rtx" in low:
-                vendor, backend = "nvidia", "cuda"
-            elif "amd" in low or "radeon" in low:
-                vendor, backend = "amd", "directml/vulkan"
-            elif "intel" in low or "arc" in low or "iris" in low:
-                vendor, backend = "intel", "directml/vulkan"
-            devices.append({"vendor": vendor, "name": item["name"], "vram_mb": item["vram_mb"], "backend": backend})
-    elif platform.system() == "Darwin":
-        sp = _cmd(["system_profiler", "SPDisplaysDataType"], timeout=8)
-        for line in sp.splitlines():
-            if "Chipset Model" in line:
-                devices.append({"vendor": "apple", "name": line.split(":", 1)[-1].strip(), "vram_mb": 0, "backend": "metal/mlx"})
-                break
-    elif platform.system() == "Linux" and not devices:
-        info = _cmd(["lspci"], timeout=5)
-        for line in info.splitlines():
-            low = line.lower()
-            if not any(token in low for token in ("vga", "3d controller", "display")):
-                continue
-            if "nvidia" in low:
-                devices.append({"vendor": "nvidia", "name": line.strip(), "vram_mb": 0, "backend": "cuda"})
-            elif "amd" in low or "advanced micro devices" in low or "radeon" in low:
-                devices.append({"vendor": "amd", "name": line.strip(), "vram_mb": 0, "backend": "rocm/vulkan"})
-            elif "intel" in low:
-                devices.append({"vendor": "intel", "name": line.strip(), "vram_mb": 0, "backend": "vulkan"})
-
-    primary = max(devices, key=lambda item: int(item.get("vram_mb") or 0), default={})
-    vram_mb = int(primary.get("vram_mb") or 0)
-    return {
-        "devices": devices,
-        "vendor": primary.get("vendor", "none"),
-        "name": primary.get("name", ""),
-        "vram_mb": vram_mb,
-        "vram_gb": round(vram_mb / 1024, 1),
-        "backend": primary.get("backend", "cpu"),
-    }
-
-
-def _detect_cuda() -> Dict[str, Any]:
-    available, version, nvidia_smi, nvcc = detect_cuda(_which_any, lambda args: _cmd(args, timeout=5))
-    return {"available": available, "nvidia_smi": nvidia_smi, "nvcc": nvcc, "version": version}
-
-
-def _detect_wsl() -> Dict[str, Any]:
-    raw = ""
-    try:
-        raw = Path("/proc/version").read_text(encoding="utf-8", errors="replace")
-    except Exception:
-        quiet()
-    is_wsl, version = detect_wsl_from_text(platform.system().lower(), raw)
-    return {"is_wsl": is_wsl, "version": version}
-
-
-def _detect_tools() -> Dict[str, bool]:
-    repair_path_for()
-    detected = detect_tools(_which_any, ["brew", "ollama", "python3", "python", "node", "npm", "git", "tesseract", "lms", "nvidia-smi", "nvcc"])
-    return {tool: path is not None for tool, path in detected.items()}
-
-def _detect_mlx() -> Dict[str, Any]:
-    return {
-        "available": _module_available("mlx"),
-        "mlx_vlm": _module_available("mlx_vlm"),
-    }
-
-def _detect_api_keys() -> Dict[str, bool]:
-    return {
-        "openai":     bool(os.getenv("OPENAI_API_KEY")),
-        "openrouter": bool(os.getenv("OPENROUTER_API_KEY")),
-        "groq":       bool(os.getenv("GROQ_API_KEY")),
-        "together":   bool(os.getenv("TOGETHER_API_KEY")),
-    }
-
-def scan_environment() -> Dict[str, Any]:
-    chip = _detect_chip()
-    cpu = _detect_cpu()
-    gpu = _detect_gpu()
-    cuda = _detect_cuda()
-    wsl = _detect_wsl()
-    tools = _detect_tools()
-    python_binary = "python3" if tools.get("python3") else "python"
-    return {
-        "os":           platform.system(),
-        "os_version":   platform.mac_ver()[0] if platform.system() == "Darwin" else platform.version(),
-        "chip":         chip,
-        "cpu":          cpu,
-        "gpu":          gpu,
-        "cuda":         cuda,
-        "wsl":          wsl,
-        "ram_gb":       _detect_ram_gb(),
-        "disk_free_gb": _detect_disk_free_gb(),
-        "tools":        tools,
-        "components": {
-            "homebrew": _component_detail("homebrew", "brew"),
-            "python": {**_component_detail("python", python_binary), "version": platform.python_version()},
-            "node": _component_detail("node", "node"),
-            "npm": _component_detail("node", "npm"),
-            "git": _component_detail("git", "git"),
-            "ollama": _component_detail("ollama", "ollama"),
-            "lmstudio": _component_detail("lmstudio", "lms"),
-            "cuda": {**_component_detail("cuda", "nvcc"), **cuda},
-            "tesseract": _component_detail("tesseract", "tesseract"),
-            "mlx": _component_detail("mlx", module="mlx"),
-            "mlx_vlm": _component_detail("mlx", module="mlx_vlm"),
-        },
-        "path": {
-            "active": os.environ.get("PATH", ""),
-            "extra": os.environ.get("LATTICEAI_EXTRA_PATH", ""),
-        },
-        "mlx":          _detect_mlx(),
-        "api_keys":     _detect_api_keys(),
-    }

package/latticeai/setup/wizard/install.py

@@ -1,348 +0,0 @@
-"""Verification, repair, and the SSE install stream.
-
-The acting half of the wizard: prove a binary or module is really there, try a
-bounded automatic repair when it is not, and stream one SSE event per step
-while pip/brew/model-load/auth actions run. Every subprocess goes through the
-process-audit command plan, and every plan is confirmed against the token the
-caller returned.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import os
-import platform
-import shutil
-import subprocess
-import sys
-import time
-from typing import Any, AsyncIterator, Dict, List, Tuple
-
-from latticeai.core.quiet import quiet
-from latticeai.services.process_audit import (
-    CommandConfirmationError,
-    append_process_audit_event,
-    command_plan,
-    require_command_confirmation,
-)
-from latticeai.setup.wizard.paths import (
-    _module_available,
-    _package_module,
-    _which_any,
-    repair_path_for,
-)
-from latticeai.setup.wizard.plans import _sse, _verify_action_confirmation
-
-
-def _verify_binary(binary: str, version_args: List[str] | None = None, timeout: int = 20) -> Tuple[bool, str]:
-    repair_path_for(binary)
-    found = _which_any(binary)
-    if not found:
-        return False, f"{binary} 실행 파일을 PATH에서 찾지 못했습니다."
-    args = [found, *(version_args or ["--version"])]
-    try:
-        completed = subprocess.run(args, capture_output=True, text=True, timeout=timeout, check=False)
-    except Exception as e:
-        return False, str(e)
-    output = (completed.stdout or completed.stderr or "").strip().splitlines()
-    if completed.returncode == 0:
-        return True, output[0] if output else found
-    return False, (completed.stderr or completed.stdout or f"returncode={completed.returncode}")[-400:]
-
-
-async def _wait_for_binary(binary: str, seconds: int = 300) -> Tuple[bool, str]:
-    deadline = time.time() + seconds
-    while time.time() < deadline:
-        ok, msg = _verify_binary(binary)
-        if ok:
-            return True, msg
-        await asyncio.sleep(2)
-    return False, f"{binary} 설치 완료를 제한 시간 안에 감지하지 못했습니다."
-
-# ── Installation Stream ───────────────────────────────────────────────────────
-
-def _verify_action(action: Dict[str, Any]) -> Tuple[bool, str]:
-    atype = action.get("type")
-    if atype == "pip":
-        modules = action.get("verify_modules") or [_package_module(pkg) for pkg in action.get("packages", [])]
-        missing = [module for module in modules if not _module_available(module)]
-        if missing:
-            return False, "Python 모듈 감지 실패: " + ", ".join(missing)
-        return True, "Python 모듈 import 테스트 통과"
-    binary = action.get("binary")
-    if binary:
-        return _verify_binary(binary)
-    return True, "검증 항목 없음"
-
-
-async def _repair_action(
-    action: Dict[str, Any],
-    *,
-    confirmation_token: str | None = None,
-    actor: str | None = None,
-) -> Tuple[bool, str]:
-    binary = action.get("binary")
-    if binary:
-        repair_path_for(binary)
-        ok, msg = _verify_binary(binary)
-        if ok:
-            return True, f"PATH 자동 보정 완료: {msg}"
-    if action.get("type") == "pip":
-        packages = action.get("packages", [])
-        if packages:
-            if not _verify_action_confirmation(action, confirmation_token, name="repair_action"):
-                return False, "설치 명령 확인 토큰이 일치하지 않습니다."
-            for pkg in packages:
-                success, err = await _pip_install(pkg, confirmed=True, actor=actor)
-                if not success:
-                    return False, err
-            return _verify_action(action)
-    return False, "자동 복구 방법을 찾지 못했습니다."
-
-
-async def install_stream(
-    items: List[Dict],
-    router: Any,
-    *,
-    confirmation_token: str | None = None,
-    user_email: str | None = None,
-) -> AsyncIterator[str]:
-    for item in items:
-        item_id    = item.get("id", "unknown")
-        name       = item.get("name", item_id)
-        action     = item.get("action") or {}
-        atype      = action.get("type")
-
-        if not atype:
-            yield _sse({"id": item_id, "status": "skipped", "msg": f"{name} — 이미 준비됨"})
-            await asyncio.sleep(0.04)
-            continue
-
-        yield _sse({"id": item_id, "status": "starting", "msg": f"{name} 준비 중..."})
-
-        if atype == "pip":
-            packages = action.get("packages", [])
-            token = confirmation_token or action.get("confirmation_token") or (action.get("command_plan") or {}).get("confirmation_token")
-            if not _verify_action_confirmation(action, token, name=str(item_id)):
-                yield _sse({"id": item_id, "status": "error", "msg": "설치 명령 확인 토큰이 일치하지 않습니다."})
-                continue
-            ok = True
-            for pkg in packages:
-                yield _sse({"id": item_id, "status": "running", "msg": f"pip install {pkg} ..."})
-                success, err = await _pip_install(pkg, confirmed=True, actor=user_email)
-                if success:
-                    yield _sse({"id": item_id, "status": "progress", "msg": f"{pkg} 설치 완료"})
-                else:
-                    yield _sse({"id": item_id, "status": "error", "msg": f"{pkg} 실패: {err[:400]}"})
-                    ok = False
-                    break
-            if ok:
-                yield _sse({"id": item_id, "status": "running", "msg": f"{name} 동작 테스트 중..."})
-                verified, detail = _verify_action(action)
-                if verified:
-                    yield _sse({"id": item_id, "status": "done", "msg": f"{name} 설치 · 검증 완료 ✅\n{detail}"})
-                else:
-                    yield _sse({"id": item_id, "status": "running", "msg": f"검증 실패 — 자동 복구 중...\n{detail}"})
-                    repaired, repair_msg = await _repair_action(action, confirmation_token=token, actor=user_email)
-                    yield _sse({"id": item_id, "status": "done" if repaired else "error", "msg": repair_msg[:500]})
-
-        elif atype == "brew":
-            pkg = action.get("package", "")
-            token = confirmation_token or action.get("confirmation_token") or (action.get("command_plan") or {}).get("confirmation_token")
-            if not _verify_action_confirmation(action, token, name=str(item_id)):
-                yield _sse({"id": item_id, "status": "error", "msg": "설치 명령 확인 토큰이 일치하지 않습니다."})
-                continue
-            yield _sse({"id": item_id, "status": "running", "msg": f"brew install {pkg} ..."})
-            success, err = await _brew_install(pkg, confirmed=True, actor=user_email)
-            if success:
-                yield _sse({"id": item_id, "status": "running", "msg": "설치 완료 감지 · PATH 보정 중..."})
-                binary = action.get("binary")
-                if binary:
-                    repair_path_for(binary)
-                verified, detail = _verify_action(action)
-                if verified:
-                    yield _sse({"id": item_id, "status": "done", "msg": f"{name} 설치 · 연결 · 검증 완료 ✅\n{detail}"})
-                else:
-                    yield _sse({"id": item_id, "status": "running", "msg": f"검증 실패 — 자동 복구 중...\n{detail}"})
-                    repaired, repair_msg = await _repair_action(action, confirmation_token=token, actor=user_email)
-                    yield _sse({"id": item_id, "status": "done" if repaired else "error", "msg": repair_msg[:500]})
-            else:
-                url = action.get("official_url") or action.get("url")
-                if url:
-                    yield _sse({"id": item_id, "status": "auth", "msg": f"자동 설치 실패 — 공식 다운로드 페이지를 엽니다.\n{err[:240]}", "auth_url": url})
-                    open_url(url)
-                yield _sse({"id": item_id, "status": "error", "msg": f"실패: {err[:400]}"})
-
-        elif atype == "load_model":
-            model_id = action.get("model_id", "")
-            yield _sse({"id": item_id, "status": "running",
-                        "msg": f"모델 다운로드 · 로딩 중...\n{model_id}\n(용량에 따라 수 분 소요)"})
-            try:
-                await router.load_model(model_id)
-                yield _sse({"id": item_id, "status": "done", "msg": f"{name} 로드 완료 ✅"})
-            except Exception as e:
-                yield _sse({"id": item_id, "status": "error", "msg": f"로드 실패: {str(e)[:400]}"})
-
-        elif atype == "auth":
-            url = action.get("url", "")
-            yield _sse({"id": item_id, "status": "auth",
-                        "msg": "브라우저에서 인증 페이지를 엽니다...", "auth_url": url})
-            open_url(url)
-            yield _sse({"id": item_id, "status": "waiting",
-                        "msg": "브라우저에서 인증 완료 후 계속하세요"})
-
-        elif atype == "url":
-            url = action.get("url", "")
-            yield _sse({"id": item_id, "status": "auth",
-                        "msg": "설치 페이지를 브라우저에서 엽니다...", "auth_url": url})
-            open_url(url)
-            binary = action.get("binary")
-            if binary:
-                yield _sse({"id": item_id, "status": "waiting",
-                            "msg": f"{binary} 설치 완료를 자동 감지하는 중입니다..."})
-                ok, detail = await _wait_for_binary(binary)
-                if ok:
-                    repair_path_for(binary)
-                    yield _sse({"id": item_id, "status": "done",
-                                "msg": f"{name} 설치 · PATH 연결 · 검증 완료 ✅\n{detail}"})
-                else:
-                    yield _sse({"id": item_id, "status": "error",
-                                "msg": f"{detail}\n공식 페이지에서 설치 후 다시 시도하세요."})
-            else:
-                yield _sse({"id": item_id, "status": "waiting",
-                            "msg": "브라우저에서 설치 또는 인증을 완료한 뒤 다시 시도하세요"})
-
-        else:
-            yield _sse({"id": item_id, "status": "error", "msg": f"알 수 없는 액션: {atype}"})
-
-    yield _sse({"status": "complete", "msg": "모든 항목 처리 완료!"})
-
-
-async def _pip_install(
-    package: str,
-    *,
-    confirmation_token: str | None = None,
-    confirmed: bool = False,
-    actor: str | None = None,
-) -> Tuple[bool, str]:
-    command = [sys.executable, "-m", "pip", "install", "--upgrade", package]
-    plan = command_plan(
-        command,
-        name=f"pip:{package}",
-        purpose="setup_wizard_install",
-        metadata={"package": package},
-    )
-    try:
-        if not confirmed:
-            require_command_confirmation(command, confirmation_token, purpose="setup_wizard_install")
-        append_process_audit_event("setup_wizard_install", plan=plan, status="started", user_email=actor)
-        proc = await asyncio.create_subprocess_exec(
-            *command,
-            stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE,
-        )
-        _, stderr = await asyncio.wait_for(proc.communicate(), timeout=600)
-        stderr_text = stderr.decode(errors="replace")
-        append_process_audit_event(
-            "setup_wizard_install",
-            plan=plan,
-            status="finished",
-            user_email=actor,
-            returncode=proc.returncode,
-            stderr=stderr_text,
-        )
-        if proc.returncode == 0:
-            return True, ""
-        return False, stderr_text
-    except CommandConfirmationError as e:
-        append_process_audit_event("setup_wizard_install", plan=plan, status="denied", user_email=actor, error=str(e))
-        return False, str(e)
-    except asyncio.TimeoutError:
-        append_process_audit_event("setup_wizard_install", plan=plan, status="timeout", user_email=actor)
-        return False, "설치 시간 초과 (10분)"
-    except Exception as e:
-        append_process_audit_event("setup_wizard_install", plan=plan, status="error", user_email=actor, error=str(e))
-        return False, str(e)
-
-
-async def _brew_install(
-    package: str,
-    *,
-    confirmation_token: str | None = None,
-    confirmed: bool = False,
-    actor: str | None = None,
-) -> Tuple[bool, str]:
-    brew = shutil.which("brew")
-    if not brew:
-        return False, "Homebrew 미설치 — https://brew.sh 에서 설치하세요"
-    command = [brew, "install", package]
-    plan = command_plan(
-        command,
-        name=f"brew:{package}",
-        purpose="setup_wizard_install",
-        metadata={"package": package},
-    )
-    try:
-        if not confirmed:
-            require_command_confirmation(command, confirmation_token, purpose="setup_wizard_install")
-        append_process_audit_event("setup_wizard_install", plan=plan, status="started", user_email=actor)
-        proc = await asyncio.create_subprocess_exec(
-            *command,
-            stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE,
-        )
-        _, stderr = await asyncio.wait_for(proc.communicate(), timeout=300)
-        stderr_text = stderr.decode(errors="replace")
-        append_process_audit_event(
-            "setup_wizard_install",
-            plan=plan,
-            status="finished",
-            user_email=actor,
-            returncode=proc.returncode,
-            stderr=stderr_text,
-        )
-        if proc.returncode == 0:
-            return True, ""
-        return False, stderr_text
-    except CommandConfirmationError as e:
-        append_process_audit_event("setup_wizard_install", plan=plan, status="denied", user_email=actor, error=str(e))
-        return False, str(e)
-    except asyncio.TimeoutError:
-        append_process_audit_event("setup_wizard_install", plan=plan, status="timeout", user_email=actor)
-        return False, "설치 시간 초과 (5분)"
-    except Exception as e:
-        append_process_audit_event("setup_wizard_install", plan=plan, status="error", user_email=actor, error=str(e))
-        return False, str(e)
-
-
-def open_url(url: str) -> None:
-    command: List[str]
-    try:
-        system = platform.system()
-        if system == "Darwin":
-            command = ["open", url]
-            plan = command_plan(command, name="open_url", purpose="setup_wizard_open_url")
-            append_process_audit_event("setup_wizard_open_url", plan=plan, status="started")
-            subprocess.Popen(command)
-            append_process_audit_event("setup_wizard_open_url", plan=plan, status="spawned")
-        elif system == "Windows":
-            command = ["os.startfile", url]
-            plan = command_plan(command, name="open_url", purpose="setup_wizard_open_url")
-            append_process_audit_event("setup_wizard_open_url", plan=plan, status="started")
-            os.startfile(url)  # type: ignore[attr-defined]  # noqa: S606 — fixed program, arguments validated by the caller
-            append_process_audit_event("setup_wizard_open_url", plan=plan, status="spawned")
-        else:
-            command = ["xdg-open", url]
-            plan = command_plan(command, name="open_url", purpose="setup_wizard_open_url")
-            append_process_audit_event("setup_wizard_open_url", plan=plan, status="started")
-            subprocess.Popen(command)
-            append_process_audit_event("setup_wizard_open_url", plan=plan, status="spawned")
-    except Exception as exc:
-        try:
-            append_process_audit_event(
-                "setup_wizard_open_url",
-                plan=command_plan(["open_url", url], name="open_url", purpose="setup_wizard_open_url"),
-                status="error",
-                error=str(exc),
-            )
-        except Exception:
-            quiet()
-        pass