refactorai-cli 0.2.24__tar.gz → 0.2.27__tar.gz

{refactorai_cli-0.2.24 → refactorai_cli-0.2.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: refactorai-cli
-Version: 0.2.24
+Version: 0.2.27
 Summary: Local-first CLI for the refactor platform
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -53,6 +53,6 @@ python -m twine upload ./refactorai-cli/dist/*
 ## Install test (local)
 
 ```bash
-python -m pip install ./refactorai-cli/dist/refactorai_cli-0.2.24-py3-none-any.whl
+python -m pip install ./refactorai-cli/dist/refactorai_cli-0.2.27-py3-none-any.whl
 refactor --version
 ```

{refactorai_cli-0.2.24 → refactorai_cli-0.2.27}/README.md

@@ -42,6 +42,6 @@ python -m twine upload ./refactorai-cli/dist/*
 ## Install test (local)
 
 ```bash
-python -m pip install ./refactorai-cli/dist/refactorai_cli-0.2.24-py3-none-any.whl
+python -m pip install ./refactorai-cli/dist/refactorai_cli-0.2.27-py3-none-any.whl
 refactor --version
 ```

{refactorai_cli-0.2.24 → refactorai_cli-0.2.27}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "refactorai-cli"
-version = "0.2.24"
+version = "0.2.27"
 description = "Local-first CLI for the refactor platform"
 readme = "README.md"
 requires-python = ">=3.11"

{refactorai_cli-0.2.24 → refactorai_cli-0.2.27}/refactorai_cli/__init__.py

@@ -5,4 +5,4 @@ the shared `refactor_core` pipeline from a project folder while staying
 authenticated to the hosted platform via a developer key.
 """
 
-__version__ = "0.2.24"
+__version__ = "0.2.27"

{refactorai_cli-0.2.24 → refactorai_cli-0.2.27}/refactorai_cli/commands/setup_cmds.py

@@ -18,6 +18,19 @@ def _ask_approval(auto_approve: bool, prompt: str) -> bool:
     return True
 
 
+def _applehv_fallback_applied() -> bool:
+    """Return True when S1 precheck applied Podman applehv fallback."""
+    payload = get_setup_diagnostics()
+    stages = payload.get("stages") or {}
+    s1 = stages.get("S1") or {}
+    if not isinstance(s1, dict):
+        return False
+    output = s1.get("output") or {}
+    if not isinstance(output, dict):
+        return False
+    return bool(output.get("podman_applehv_fallback_applied"))
+
+
 def setup(
     yes: bool = typer.Option(False, "--yes", help="Auto-approve setup actions."),
     resume: bool = typer.Option(False, "--resume", help="Resume from last incomplete stage."),
@@ -66,5 +79,13 @@ def setup(
     console.print("[green]Setup completed successfully.[/green]")
     if result.execution_backend:
         console.print(f"[bold]backend[/bold]: {result.execution_backend}")
+    if result.sandbox_ready is True:
+        runtime = result.sandbox_runtime or "podman"
+        console.print(f"[bold]sandbox[/bold]: ready ({runtime})")
+    elif result.sandbox_ready is False:
+        detail = result.sandbox_reason or "Podman missing or not ready."
+        console.print(f"[yellow]sandbox[/yellow]: not ready ({detail})")
+    if _applehv_fallback_applied():
+        console.print("[yellow]sandbox fallback[/yellow]: applied provider=applehv")
     console.print(f"[bold]completed stages[/bold]: {', '.join(result.completed_stages)}")
     console.print("[bold]next[/bold]: run `refactor init` and then `refactor review .`")

{refactorai_cli-0.2.24 → refactorai_cli-0.2.27}/refactorai_cli/setup_flow.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 import json
 import shutil
+import subprocess
+import sys
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
@@ -55,6 +57,9 @@ class SetupResult:
     completed_stages: list[str]
     last_error: str = ""
     execution_backend: str = ""
+    sandbox_ready: bool | None = None
+    sandbox_runtime: str = ""
+    sandbox_reason: str = ""
 
 
 def _now_iso() -> str:
@@ -147,19 +152,267 @@ def get_setup_diagnostics() -> dict:
     return {"state": state, "stages": stages}
 
 
+def _host_runtime_install_plan(runtime: str) -> list[str]:
+    """Return host-level install commands for a missing runtime binary."""
+    rt = (runtime or "").strip().lower()
+    if rt != "podman":
+        return []
+    if shutil.which("apt-get"):
+        return ["sudo apt-get update", "sudo apt-get install -y podman"]
+    if shutil.which("dnf"):
+        return ["sudo dnf install -y podman"]
+    if shutil.which("yum"):
+        return ["sudo yum install -y podman"]
+    if shutil.which("apk"):
+        return ["sudo apk add --no-cache podman"]
+    if shutil.which("pacman"):
+        return ["sudo pacman -Sy --noconfirm podman"]
+    if shutil.which("brew"):
+        plan = ["brew install podman"]
+        if sys.platform == "darwin":
+            plan.extend(
+                [
+                    "podman machine inspect >/dev/null 2>&1 || podman machine init",
+                    "podman machine start",
+                ]
+            )
+        return plan
+    return []
+
+
+def _host_runtime_repair_plan(runtime: str) -> list[str]:
+    """Return host-level repair commands for an installed runtime."""
+    rt = (runtime or "").strip().lower()
+    if rt != "podman":
+        return []
+    if sys.platform == "darwin":
+        return [
+            "podman machine inspect >/dev/null 2>&1 || podman machine init",
+            "podman machine start",
+        ]
+    return []
+
+
+def _is_krunkit_missing_error(detail: str) -> bool:
+    """Detect Podman startup failures caused by missing krunkit on macOS."""
+    text = str(detail or "").strip().lower()
+    return "krunkit" in text and ("not found" in text or "executable file" in text)
+
+
+def _podman_applehv_fallback_plan() -> list[str]:
+    """Return recovery commands to recreate Podman machine with applehv."""
+    if sys.platform != "darwin":
+        return []
+    return [
+        "podman machine stop >/dev/null 2>&1 || true",
+        "podman machine rm --force >/dev/null 2>&1 || true",
+        "podman machine init --provider applehv",
+        "podman machine start",
+    ]
+
+
+def _run_host_plan(commands: list[str], emit: Callable[[str], None] | None = None) -> tuple[bool, str]:
+    """Run host-level setup commands sequentially."""
+    for command in commands:
+        if emit:
+            emit(f"Executing host command: {command}")
+        proc = subprocess.run(command, shell=True, capture_output=True, text=True)
+        if proc.returncode != 0:
+            detail = (proc.stderr or proc.stdout or "").strip()[:500]
+            return False, f"`{command}` -> {detail or 'unknown error'}"
+    return True, ""
+
+
+def _podman_runtime_ready(runtime: str) -> tuple[bool, str]:
+    """Return whether Podman is installed and ready for container operations."""
+    try:
+        proc = subprocess.run([runtime, "info"], capture_output=True, text=True)
+    except OSError as exc:
+        return False, str(exc)
+    if proc.returncode == 0:
+        return True, ""
+    detail = (proc.stderr or proc.stdout or "").strip()[:500]
+    return False, detail or "Podman runtime is installed but not ready."
+
+
+def _sandbox_summary_from_precheck() -> tuple[bool | None, str, str]:
+    """Read S1 output and derive sandbox readiness summary for CLI output."""
+    path = stage_output_path("S1")
+    if not path.is_file():
+        return None, "", ""
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return None, "", ""
+    output = payload.get("output")
+    if not isinstance(output, dict):
+        return None, "", ""
+    ready_raw = output.get("podman_ready")
+    available_raw = output.get("podman_available")
+    sandbox_ready: bool | None = None
+    if isinstance(ready_raw, bool):
+        sandbox_ready = ready_raw
+    elif isinstance(available_raw, bool):
+        sandbox_ready = available_raw
+    reason = str(output.get("podman_ready_reason") or output.get("podman_reason") or "").strip()
+    runtime = "podman" if sandbox_ready is not None else ""
+    return sandbox_ready, runtime, reason
+
+
 def _stage_s1_precheck(_ask_approval: Callable[[str], bool], _emit: Callable[[str], None] | None = None) -> dict:
     profile = detect_machine_profile()
     runtime, reason = resolve_engine_runtime("podman")
+    podman_install_plan: list[str] = []
+    podman_install_approved = False
+    podman_install_attempted = False
+    podman_repair_plan: list[str] = []
+    podman_repair_approved = False
+    podman_repair_attempted = False
+    podman_applehv_fallback_plan: list[str] = []
+    podman_applehv_fallback_approved = False
+    podman_applehv_fallback_attempted = False
+    podman_applehv_fallback_applied = False
+    podman_applehv_fallback_error = ""
     disk = shutil.disk_usage(str(refactor_home()))
     blockers: list[str] = []
     if disk.free < 2 * 1024 * 1024 * 1024:
         blockers.append("Less than 2GB free disk available in REFACTOR_HOME filesystem.")
     if blockers:
         raise SetupError("Precheck failed: " + "; ".join(blockers))
+
+    def _attempt_applehv_fallback(failure_detail: str) -> bool:
+        nonlocal podman_applehv_fallback_plan
+        nonlocal podman_applehv_fallback_approved
+        nonlocal podman_applehv_fallback_attempted
+        nonlocal podman_applehv_fallback_applied
+        nonlocal podman_applehv_fallback_error
+        if not _is_krunkit_missing_error(failure_detail):
+            return False
+        if not podman_applehv_fallback_plan:
+            podman_applehv_fallback_plan = _podman_applehv_fallback_plan()
+        if not podman_applehv_fallback_plan:
+            return False
+        if _emit:
+            _emit(
+                "Detected Podman startup failure due to missing `krunkit`. "
+                "Offering Apple Hypervisor fallback..."
+            )
+        podman_applehv_fallback_approved = _ask_approval(
+            "Podman start failed because `krunkit` is missing. "
+            "Recreate Podman machine with `applehv` provider now? "
+            "This can remove existing Podman machine state."
+        )
+        if not podman_applehv_fallback_approved:
+            podman_applehv_fallback_error = "fallback_not_approved"
+            return False
+        podman_applehv_fallback_attempted = True
+        if _emit:
+            _emit("Applying Podman fallback with `applehv` provider...")
+        ok, fallback_detail = _run_host_plan(podman_applehv_fallback_plan, emit=_emit)
+        if not ok:
+            podman_applehv_fallback_error = fallback_detail
+            return False
+        podman_applehv_fallback_applied = True
+        podman_applehv_fallback_error = ""
+        return True
+
+    def _applehv_manual_hint() -> str:
+        if not podman_applehv_fallback_plan:
+            return ""
+        return " To recover on macOS, run: " + "; ".join(podman_applehv_fallback_plan) + "."
+
+    if not runtime:
+        podman_install_plan = _host_runtime_install_plan("podman")
+        if podman_install_plan:
+            podman_install_approved = _ask_approval(
+                "Install Podman host runtime now so sandboxed review can run?"
+            )
+            if podman_install_approved:
+                podman_install_attempted = True
+                if _emit:
+                    _emit("Podman was not found. Running guided host install plan...")
+                ok, detail = _run_host_plan(podman_install_plan, emit=_emit)
+                if not ok:
+                    if _attempt_applehv_fallback(detail):
+                        runtime, reason = resolve_engine_runtime("podman")
+                        if not runtime:
+                            raise SetupError(
+                                "Apple Hypervisor fallback completed but Podman is still unavailable. "
+                                "Verify PATH and retry (`refactor doctor --sandbox`)."
+                            )
+                    else:
+                        fallback_hint = _applehv_manual_hint()
+                        raise SetupError(
+                            "Podman host install failed: "
+                            f"{detail}.{fallback_hint} Install manually and retry (`refactor doctor --sandbox`)."
+                        )
+                if not runtime:
+                    runtime, reason = resolve_engine_runtime("podman")
+                if not runtime:
+                    raise SetupError(
+                        "Podman install completed but runtime is still unavailable. "
+                        "Verify PATH and retry (`refactor doctor --sandbox`)."
+                    )
+        elif _emit:
+            _emit("Podman is missing and no automated install plan is available on this host.")
+
+    podman_ready = False
+    podman_ready_reason = reason
+    if runtime:
+        podman_ready, podman_ready_reason = _podman_runtime_ready(str(runtime))
+        if not podman_ready:
+            podman_repair_plan = _host_runtime_repair_plan(str(runtime))
+            if podman_repair_plan:
+                podman_repair_approved = _ask_approval(
+                    "Podman is installed but not ready. Initialize/start Podman machine now?"
+                )
+                if podman_repair_approved:
+                    podman_repair_attempted = True
+                    if _emit:
+                        _emit("Podman is installed but not ready. Running repair plan...")
+                    ok, detail = _run_host_plan(podman_repair_plan, emit=_emit)
+                    if not ok:
+                        if not _attempt_applehv_fallback(detail):
+                            raise SetupError(
+                                "Podman runtime repair failed: "
+                                f"{detail}.{_applehv_manual_hint()} Run `podman machine start` and retry."
+                            )
+                    podman_ready, podman_ready_reason = _podman_runtime_ready(str(runtime))
+                    if not podman_ready:
+                        raise SetupError(
+                            "Podman is installed but still not ready after repair: "
+                            f"{podman_ready_reason}"
+                        )
+    if _emit:
+        if runtime and podman_ready:
+            _emit("Sandbox runtime precheck: Podman is ready.")
+        elif runtime:
+            _emit(
+                "Sandbox runtime precheck: Podman is installed but not ready. "
+                "Setup can continue, but `refactor review` may fail until Podman is started."
+            )
+        else:
+            _emit(
+                "Sandbox runtime precheck: Podman is not installed. "
+                "Setup can continue, but sandboxed review requires Podman."
+            )
     return {
         "profile": profile,
         "podman_available": bool(runtime),
         "podman_reason": reason,
+        "podman_ready": bool(runtime and podman_ready),
+        "podman_ready_reason": podman_ready_reason,
+        "podman_install_plan": podman_install_plan,
+        "podman_install_approved": podman_install_approved,
+        "podman_install_attempted": podman_install_attempted,
+        "podman_repair_plan": podman_repair_plan,
+        "podman_repair_approved": podman_repair_approved,
+        "podman_repair_attempted": podman_repair_attempted,
+        "podman_applehv_fallback_plan": podman_applehv_fallback_plan,
+        "podman_applehv_fallback_approved": podman_applehv_fallback_approved,
+        "podman_applehv_fallback_attempted": podman_applehv_fallback_attempted,
+        "podman_applehv_fallback_applied": podman_applehv_fallback_applied,
+        "podman_applehv_fallback_error": podman_applehv_fallback_error,
         "disk_free_mb": int(disk.free / (1024 * 1024)),
     }
 
@@ -399,7 +652,15 @@ def run_setup(
     elif resume:
         pending = [stage for stage in STAGE_IDS if stage not in completed]
         if not pending:
-            return SetupResult(status="already_completed", completed_stages=completed, last_error="")
+            sandbox_ready, sandbox_runtime, sandbox_reason = _sandbox_summary_from_precheck()
+            return SetupResult(
+                status="already_completed",
+                completed_stages=completed,
+                last_error="",
+                sandbox_ready=sandbox_ready,
+                sandbox_runtime=sandbox_runtime,
+                sandbox_reason=sandbox_reason,
+            )
         start_index = STAGE_IDS.index(pending[0])
     else:
         start_index = 0
@@ -478,9 +739,13 @@ def run_setup(
             "last_error": "",
         }
     )
+    sandbox_ready, sandbox_runtime, sandbox_reason = _sandbox_summary_from_precheck()
     return SetupResult(
         status="completed",
         completed_stages=completed,
         last_error="",
         execution_backend=final_backend,
+        sandbox_ready=sandbox_ready,
+        sandbox_runtime=sandbox_runtime,
+        sandbox_reason=sandbox_reason,
     )

{refactorai_cli-0.2.24 → refactorai_cli-0.2.27}/refactorai_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: refactorai-cli
-Version: 0.2.24
+Version: 0.2.27
 Summary: Local-first CLI for the refactor platform
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -53,6 +53,6 @@ python -m twine upload ./refactorai-cli/dist/*
 ## Install test (local)
 
 ```bash
-python -m pip install ./refactorai-cli/dist/refactorai_cli-0.2.24-py3-none-any.whl
+python -m pip install ./refactorai-cli/dist/refactorai_cli-0.2.27-py3-none-any.whl
 refactor --version
 ```