remo-cli 2.0.0rc1__tar.gz → 2.0.0rc2__tar.gz

{remo_cli-2.0.0rc1 → remo_cli-2.0.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remo-cli
-Version: 2.0.0rc1
+Version: 2.0.0rc2
 Summary: Remote development environment CLI
 License-Expression: MIT
 License-File: LICENSE

{remo_cli-2.0.0rc1 → remo_cli-2.0.0rc2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "remo-cli"
-version = "2.0.0rc1"
+version = "2.0.0rc2"
 description = "Remote development environment CLI"
 readme = "README.md"
 license = "MIT"

{remo_cli-2.0.0rc1 → remo_cli-2.0.0rc2}/src/remo_cli/cli/shell.py

@@ -33,7 +33,7 @@ def shell(
 ) -> None:
     """Connect to a remo environment (auto-detects or picker)."""
     from remo_cli.core.ssh import check_remote_version, resolve_remo_host, shell_connect  # noqa: PLC0415
-    from remo_cli.core.output import confirm, print_warning  # noqa: PLC0415
+    from remo_cli.core.output import confirm, print_error, print_warning  # noqa: PLC0415
     from remo_cli.core.version import get_current_version, version_is_newer  # noqa: PLC0415
     from remo_cli.providers.aws import auto_start_aws_if_stopped  # noqa: PLC0415
 
@@ -46,10 +46,20 @@ def shell(
     if not no_update_check:
         local_version = get_current_version()
         if local_version != "unknown":
-            remote_version = check_remote_version(host)
+            remote_version, remote_err = check_remote_version(host)
 
             should_update = False
-            if remote_version is None:
+            if remote_err is not None:
+                # SSH itself failed — we can't tell whether the marker exists
+                # or what version is on the box. Don't prompt to update from
+                # an unknown baseline; surface the error so the user can fix
+                # it (DNS, host key, auth, ...) and re-run.
+                print_warning(
+                    f"Could not check tools version on '{host.name}':\n"
+                    f"  {remote_err}\n"
+                    f"  Skipping update check; proceeding with connection."
+                )
+            elif remote_version is None:
                 # No marker file on remote
                 should_update = confirm(
                     f"Instance '{host.name}' has no version info. Update tools?",
@@ -71,29 +81,45 @@ def shell(
                 )
 
             if should_update:
-                _run_provider_update(host)
+                rc = _run_provider_update(host)
+                if rc != 0:
+                    # The playbook log has already been dumped, but the SSH
+                    # connection (and any remote project picker) would scroll
+                    # it offscreen immediately. Pause so the user can read it.
+                    print_error(
+                        f"Tools update for '{host.name}' failed "
+                        f"(ansible-playbook exit code {rc})."
+                    )
+                    if not confirm(
+                        "Connect anyway?",
+                        default=False,
+                    ):
+                        raise SystemExit(rc)
 
     shell_connect(host, list(tunnels), no_open)
 
 
-def _run_provider_update(host) -> None:  # noqa: ANN001
-    """Run the appropriate provider update for the given host."""
+def _run_provider_update(host) -> int:  # noqa: ANN001
+    """Run the appropriate provider update for the given host.
+
+    Returns the provider update's exit code (0 on success).
+    """
     from remo_cli.core.output import print_info  # noqa: PLC0415
 
     print_info(f"Updating instance '{host.name}'...")
 
     if host.type == "aws":
         from remo_cli.providers.aws import update as aws_update  # noqa: PLC0415
-        aws_update(name=host.name)
-    elif host.type == "hetzner":
+        return aws_update(name=host.name)
+    if host.type == "hetzner":
         from remo_cli.providers.hetzner import update as hetzner_update  # noqa: PLC0415
-        hetzner_update(name=host.name)
-    elif host.type == "incus":
+        return hetzner_update(name=host.name)
+    if host.type == "incus":
         from remo_cli.providers.incus import update as incus_update  # noqa: PLC0415
         # Incus name in known_hosts is "host/container" — extract just the container name
         container_name = host.name.split("/", maxsplit=1)[-1] if "/" in host.name else host.name
-        incus_update(name=container_name)
-    elif host.type == "proxmox":
+        return incus_update(name=container_name)
+    if host.type == "proxmox":
         from remo_cli.providers.proxmox import update as proxmox_update  # noqa: PLC0415
         # Proxmox name in known_hosts is "node/container".
         # The proxmox SSH user is stored in the region slot (see providers.proxmox.create).
@@ -101,8 +127,9 @@ def _run_provider_update(host) -> None:  # noqa: ANN001
         if not container_name:
             container_name = host.name
             proxmox_host = ""
-        proxmox_update(
+        return proxmox_update(
             name=container_name,
             host=proxmox_host,
             user=host.region or "",
         )
+    return 0

{remo_cli-2.0.0rc1 → remo_cli-2.0.0rc2}/src/remo_cli/core/ssh.py

@@ -257,24 +257,46 @@ def detect_timezone() -> str:
     return ""
 
 
-def check_remote_version(host: KnownHost) -> str | None:
+def check_remote_version(host: KnownHost) -> tuple[str | None, str | None]:
     """Read the remo version marker from the remote instance.
 
-    Runs ``cat ~/.remo-version`` over SSH and returns the version string,
-    or ``None`` if the file doesn't exist or SSH fails.
+    Runs ``cat ~/.remo-version`` over SSH. Returns a ``(version, error)``
+    tuple where exactly one element is non-None:
+
+    * ``(version, None)`` — marker present and readable.
+    * ``(None, None)``    — SSH succeeded but the marker is missing/empty.
+    * ``(None, error)``   — SSH itself failed (DNS, host key, network,
+      timeout, ...); *error* is the underlying message so the caller can
+      surface it to the user.
     """
     ssh_opts, ssh_target = build_ssh_opts(host)
-    cmd = ["ssh"] + ssh_opts + ["-o", "ConnectTimeout=10", ssh_target, "cat ~/.remo-version 2>/dev/null"]
+    cmd = ["ssh"] + ssh_opts + [
+        "-o", "ConnectTimeout=10",
+        "-o", "BatchMode=yes",
+        ssh_target,
+        "cat ~/.remo-version 2>/dev/null",
+    ]
 
     try:
         result = subprocess.run(cmd, capture_output=True, text=True, timeout=15)
-        version = result.stdout.strip()
-        if result.returncode == 0 and version:
-            return version
-    except (subprocess.TimeoutExpired, OSError):
-        pass
-
-    return None
+    except subprocess.TimeoutExpired:
+        return None, "SSH timed out after 15s"
+    except OSError as e:
+        return None, f"SSH failed: {e}"
+
+    # ssh exits with 255 for its own failures (auth, host key, DNS,
+    # connection refused, ...). Any other non-zero exit code comes from
+    # the remote command — here, `cat` failing because the marker is
+    # absent — which we treat as "no marker" rather than an SSH error.
+    if result.returncode == 255:
+        stderr = result.stderr.strip()
+        return None, stderr or "SSH connection failed (exit code 255)"
+
+    version = result.stdout.strip()
+    if result.returncode == 0 and version:
+        return version, None
+
+    return None, None
 
 
 def shell_connect(host: KnownHost, tunnels: list[str], no_open: bool) -> None:

{remo_cli-2.0.0rc1 → remo_cli-2.0.0rc2}/tests/unit/cli/test_shell.py

@@ -52,7 +52,7 @@ class TestShellVersionCheck:
     def test_equal_versions_proceeds_silently(self, runner, mocker):
         """When remote and local versions match, no prompt is shown."""
         mocker.patch("remo_cli.core.version.get_current_version", return_value="0.8.0")
-        mocker.patch("remo_cli.core.ssh.check_remote_version", return_value="0.8.0")
+        mocker.patch("remo_cli.core.ssh.check_remote_version", return_value=("0.8.0", None))
         mock_confirm = mocker.patch("remo_cli.core.output.confirm")
 
         result = runner.invoke(shell, [])
@@ -64,7 +64,7 @@ class TestShellVersionCheck:
     def test_remote_behind_prompts_update(self, runner, mocker):
         """When remote is behind local, user is prompted to update."""
         mocker.patch("remo_cli.core.version.get_current_version", return_value="0.9.0")
-        mocker.patch("remo_cli.core.ssh.check_remote_version", return_value="0.8.0")
+        mocker.patch("remo_cli.core.ssh.check_remote_version", return_value=("0.8.0", None))
         mock_confirm = mocker.patch("remo_cli.core.output.confirm", return_value=False)
 
         result = runner.invoke(shell, [])
@@ -78,7 +78,7 @@ class TestShellVersionCheck:
     def test_remote_behind_update_accepted(self, runner, mocker):
         """When user accepts update, provider update is called."""
         mocker.patch("remo_cli.core.version.get_current_version", return_value="0.9.0")
-        mocker.patch("remo_cli.core.ssh.check_remote_version", return_value="0.8.0")
+        mocker.patch("remo_cli.core.ssh.check_remote_version", return_value=("0.8.0", None))
         mocker.patch("remo_cli.core.output.confirm", return_value=True)
         mock_update = mocker.patch("remo_cli.providers.hetzner.update", return_value=0)
 
@@ -87,11 +87,45 @@ class TestShellVersionCheck:
         assert result.exit_code == 0
         mock_update.assert_called_once_with(name="webserver")
 
+    @pytest.mark.usefixtures("_patch_shell_deps")
+    def test_update_failure_prompts_before_connect(self, runner, mocker):
+        """When tools update fails, user is prompted to confirm connect."""
+        mocker.patch("remo_cli.core.version.get_current_version", return_value="0.9.0")
+        mocker.patch("remo_cli.core.ssh.check_remote_version", return_value=("0.8.0", None))
+        # First confirm() = "Update?" → True; second = "Connect anyway?" → True
+        mock_confirm = mocker.patch(
+            "remo_cli.core.output.confirm", side_effect=[True, True]
+        )
+        mocker.patch("remo_cli.providers.hetzner.update", return_value=2)
+        mock_shell_connect = mocker.patch("remo_cli.core.ssh.shell_connect")
+
+        result = runner.invoke(shell, [])
+
+        assert result.exit_code == 0
+        assert mock_confirm.call_count == 2
+        assert "Connect anyway?" in mock_confirm.call_args_list[1][0][0]
+        mock_shell_connect.assert_called_once()
+
+    @pytest.mark.usefixtures("_patch_shell_deps")
+    def test_update_failure_decline_aborts(self, runner, mocker):
+        """When user declines after failed update, shell_connect is not called."""
+        mocker.patch("remo_cli.core.version.get_current_version", return_value="0.9.0")
+        mocker.patch("remo_cli.core.ssh.check_remote_version", return_value=("0.8.0", None))
+        # First confirm() = "Update?" → True; second = "Connect anyway?" → False
+        mocker.patch("remo_cli.core.output.confirm", side_effect=[True, False])
+        mocker.patch("remo_cli.providers.hetzner.update", return_value=2)
+        mock_shell_connect = mocker.patch("remo_cli.core.ssh.shell_connect")
+
+        result = runner.invoke(shell, [])
+
+        assert result.exit_code == 2
+        mock_shell_connect.assert_not_called()
+
     @pytest.mark.usefixtures("_patch_shell_deps")
     def test_remote_ahead_shows_warning(self, runner, mocker):
         """When remote is ahead of local, a warning is shown."""
         mocker.patch("remo_cli.core.version.get_current_version", return_value="0.8.0")
-        mocker.patch("remo_cli.core.ssh.check_remote_version", return_value="0.9.0")
+        mocker.patch("remo_cli.core.ssh.check_remote_version", return_value=("0.9.0", None))
         mock_confirm = mocker.patch("remo_cli.core.output.confirm")
 
         result = runner.invoke(shell, [])
@@ -105,7 +139,7 @@ class TestShellVersionCheck:
     def test_no_marker_prompts_update(self, runner, mocker):
         """When remote has no version marker, user is prompted to update."""
         mocker.patch("remo_cli.core.version.get_current_version", return_value="0.8.0")
-        mocker.patch("remo_cli.core.ssh.check_remote_version", return_value=None)
+        mocker.patch("remo_cli.core.ssh.check_remote_version", return_value=(None, None))
         mock_confirm = mocker.patch("remo_cli.core.output.confirm", return_value=False)
 
         result = runner.invoke(shell, [])
@@ -114,6 +148,25 @@ class TestShellVersionCheck:
         mock_confirm.assert_called_once()
         assert "no version info" in mock_confirm.call_args[0][0]
 
+    @pytest.mark.usefixtures("_patch_shell_deps")
+    def test_ssh_error_skips_update_prompt(self, runner, mocker):
+        """When SSH itself fails, the user is warned and not prompted to update."""
+        mocker.patch("remo_cli.core.version.get_current_version", return_value="0.8.0")
+        mocker.patch(
+            "remo_cli.core.ssh.check_remote_version",
+            return_value=(None, "Host key verification failed."),
+        )
+        mock_confirm = mocker.patch("remo_cli.core.output.confirm")
+        mock_shell_connect = mocker.patch("remo_cli.core.ssh.shell_connect")
+
+        result = runner.invoke(shell, [])
+
+        assert result.exit_code == 0
+        mock_confirm.assert_not_called()
+        assert "Could not check tools version" in result.output
+        assert "Host key verification failed." in result.output
+        mock_shell_connect.assert_called_once()
+
     @pytest.mark.usefixtures("_patch_shell_deps")
     def test_unknown_local_version_skips_check(self, runner, mocker):
         """When local version is unknown, skip the version check."""

{remo_cli-2.0.0rc1 → remo_cli-2.0.0rc2}/tests/unit/core/test_ssh.py

@@ -395,51 +395,71 @@ class TestCheckRemoteVersion:
 
     @pytest.mark.usefixtures("_suppress_tz")
     def test_returns_version_on_success(self, hetzner_host, mocker):
-        """Returns the version string when SSH succeeds."""
+        """Returns (version, None) when SSH succeeds and marker is present."""
         mocker.patch("remo_cli.core.ssh.get_aws_region", return_value="us-west-2")
         mock_run = mocker.patch(
             "subprocess.run",
-            return_value=MagicMock(returncode=0, stdout="0.8.0rc1\n"),
+            return_value=MagicMock(returncode=0, stdout="0.8.0rc1\n", stderr=""),
         )
 
         from remo_cli.core.ssh import check_remote_version
 
-        result = check_remote_version(hetzner_host)
-        assert result == "0.8.0rc1"
+        assert check_remote_version(hetzner_host) == ("0.8.0rc1", None)
 
         # Verify SSH command includes cat ~/.remo-version
         call_args = mock_run.call_args[0][0]
         assert "cat ~/.remo-version 2>/dev/null" in call_args
+        # And uses BatchMode so it can't hang on host-key/auth prompts
+        assert "BatchMode=yes" in call_args
 
     @pytest.mark.usefixtures("_suppress_tz")
-    def test_returns_none_on_missing_file(self, hetzner_host, mocker):
-        """Returns None when the remote file doesn't exist (rc != 0)."""
+    def test_returns_no_marker_on_missing_file(self, hetzner_host, mocker):
+        """Returns (None, None) when the remote command failed (cat → marker missing)."""
         mocker.patch("remo_cli.core.ssh.get_aws_region", return_value="us-west-2")
         mocker.patch(
             "subprocess.run",
-            return_value=MagicMock(returncode=1, stdout=""),
+            return_value=MagicMock(returncode=1, stdout="", stderr=""),
         )
 
         from remo_cli.core.ssh import check_remote_version
 
-        assert check_remote_version(hetzner_host) is None
+        assert check_remote_version(hetzner_host) == (None, None)
 
     @pytest.mark.usefixtures("_suppress_tz")
-    def test_returns_none_on_empty_output(self, hetzner_host, mocker):
-        """Returns None when SSH succeeds but output is empty."""
+    def test_returns_no_marker_on_empty_output(self, hetzner_host, mocker):
+        """Returns (None, None) when SSH succeeds but the marker is empty."""
         mocker.patch("remo_cli.core.ssh.get_aws_region", return_value="us-west-2")
         mocker.patch(
             "subprocess.run",
-            return_value=MagicMock(returncode=0, stdout=""),
+            return_value=MagicMock(returncode=0, stdout="", stderr=""),
         )
 
         from remo_cli.core.ssh import check_remote_version
 
-        assert check_remote_version(hetzner_host) is None
+        assert check_remote_version(hetzner_host) == (None, None)
 
     @pytest.mark.usefixtures("_suppress_tz")
-    def test_returns_none_on_timeout(self, hetzner_host, mocker):
-        """Returns None when SSH times out."""
+    def test_returns_error_on_ssh_failure(self, hetzner_host, mocker):
+        """Returns (None, stderr) when SSH itself fails (rc 255)."""
+        mocker.patch("remo_cli.core.ssh.get_aws_region", return_value="us-west-2")
+        mocker.patch(
+            "subprocess.run",
+            return_value=MagicMock(
+                returncode=255,
+                stdout="",
+                stderr="Host key verification failed.\n",
+            ),
+        )
+
+        from remo_cli.core.ssh import check_remote_version
+
+        version, err = check_remote_version(hetzner_host)
+        assert version is None
+        assert err == "Host key verification failed."
+
+    @pytest.mark.usefixtures("_suppress_tz")
+    def test_returns_error_on_timeout(self, hetzner_host, mocker):
+        """Returns (None, error) when SSH times out."""
         mocker.patch("remo_cli.core.ssh.get_aws_region", return_value="us-west-2")
         mocker.patch(
             "subprocess.run",
@@ -448,14 +468,20 @@ class TestCheckRemoteVersion:
 
         from remo_cli.core.ssh import check_remote_version
 
-        assert check_remote_version(hetzner_host) is None
+        version, err = check_remote_version(hetzner_host)
+        assert version is None
+        assert err is not None
+        assert "timed out" in err.lower()
 
     @pytest.mark.usefixtures("_suppress_tz")
-    def test_returns_none_on_os_error(self, hetzner_host, mocker):
-        """Returns None when SSH binary is not found."""
+    def test_returns_error_on_os_error(self, hetzner_host, mocker):
+        """Returns (None, error) when the ssh binary can't be invoked."""
         mocker.patch("remo_cli.core.ssh.get_aws_region", return_value="us-west-2")
         mocker.patch("subprocess.run", side_effect=OSError("No ssh"))
 
         from remo_cli.core.ssh import check_remote_version
 
-        assert check_remote_version(hetzner_host) is None
+        version, err = check_remote_version(hetzner_host)
+        assert version is None
+        assert err is not None
+        assert "No ssh" in err

{remo_cli-2.0.0rc1 → remo_cli-2.0.0rc2}/uv.lock

@@ -771,7 +771,7 @@ wheels = [
 
 [[package]]
 name = "remo-cli"
-version = "1.0.2"
+version = "2.0.0rc2"
 source = { editable = "." }
 dependencies = [
     { name = "ansible-core" },