pi-sync-cli 0.1.0__tar.gz → 0.2.0__tar.gz

{pi_sync_cli-0.1.0 → pi_sync_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pi-sync-cli
-Version: 0.1.0
+Version: 0.2.0
 Summary: Sync pi agent config and extensions between hosts over rsync
 Project-URL: Repository, https://github.com/say4n/pi-sync
 Project-URL: Issues, https://github.com/say4n/pi-sync/issues
@@ -62,6 +62,7 @@ Host-local state is deliberately never touched: `sessions/`, `npm/`,
 | `--delete` | mirror `extensions/` exactly (deletes extras on the destination) |
 | `--dry-run` | report changes, copy nothing |
 | `-x, --exclude PATTERN` | skip matching files (repeatable) |
+| `--install` | install pi on hosts that lack it, without prompting |
 | `--local-dir` | default `$PI_CODING_AGENT_DIR` or `~/.pi/agent` |
 | `--remote-dir` | default `~/.pi/agent` |
 | `-v` / `--verbose` | print each rsync command and its output |
@@ -69,6 +70,59 @@ Host-local state is deliberately never touched: `sessions/`, `npm/`,
 Multiple hosts are accepted: `pi-sync a b c`. Exits non-zero if any host is
 unreachable or any transfer fails.
 
+## Host preflight
+
+Each host gets one ssh probe that reports reachability and pi's location in the
+same round trip.
+
+If pi is missing, pi-sync hands the terminal to pi's own installer
+(`curl -fsSL https://pi.dev/install.sh | sh`), which keeps full control: its
+prompts (its install/uninstall/do-nothing menu, a Node.js install, a sudo
+password) work normally, and the sync continues once it exits. pi-sync does not
+add a confirmation of its own, because the installer already asks. Without a
+terminal it runs unattended under `--install`, stays quiet otherwise, and
+`--dry-run` never installs anything.
+
+The installer's exit status is not treated as proof: its "do nothing" choice
+exits 0, so the host is re-probed afterwards and reported honestly.
+
+**A host without pi is skipped** — copying into a host that has never run pi is
+not useful and usually fails anyway, since there is no agent directory to copy
+into. That covers an installer run that installed nothing, a failed install, and
+a non-interactive run without `--install`; a skipped host makes the run exit
+non-zero. After a successful install pi-sync creates the agent directory,
+because rsync will not create intermediate directories on its own.
+
+The probe checks `command -v pi` plus the usual install locations
+(`~/.local/bin`, `~/.pi/bin`, `~/.pi/agent/bin`, linuxbrew, homebrew,
+`/usr/local/bin`), because a non-interactive ssh session does not source the
+host's shell init — on a linuxbrew host `command -v pi` alone misses it.
+
+## Shell completions
+
+Host arguments complete from `~/.ssh/config`, following `Include` directives and
+skipping wildcard entries:
+
+```bash
+# bash
+_PI_SYNC_COMPLETE=bash_source pi-sync > ~/.pi-sync-complete.bash
+echo 'source ~/.pi-sync-complete.bash' >> ~/.bashrc
+
+# zsh
+_PI_SYNC_COMPLETE=zsh_source pi-sync > ~/.pi-sync-complete.zsh
+echo 'source ~/.pi-sync-complete.zsh' >> ~/.zshrc
+
+# fish (config.fish)
+_PI_SYNC_COMPLETE=fish_source pi-sync | source
+```
+
+Writing the script out (rather than `eval "$(_PI_SYNC_COMPLETE=bash_source pi-sync)"`
+on every shell start) keeps shell startup fast, since the eval form runs the
+binary each time. PowerShell works the same way via `powershell_source`.
+
+Completions are read from the config at completion time, so new hosts appear
+without regenerating anything.
+
 ## Caveats
 
 - `settings.json` is machine-written by pi (`lastChangelogVersion` bumps, UI

{pi_sync_cli-0.1.0 → pi_sync_cli-0.2.0}/README.md

@@ -45,6 +45,7 @@ Host-local state is deliberately never touched: `sessions/`, `npm/`,
 | `--delete` | mirror `extensions/` exactly (deletes extras on the destination) |
 | `--dry-run` | report changes, copy nothing |
 | `-x, --exclude PATTERN` | skip matching files (repeatable) |
+| `--install` | install pi on hosts that lack it, without prompting |
 | `--local-dir` | default `$PI_CODING_AGENT_DIR` or `~/.pi/agent` |
 | `--remote-dir` | default `~/.pi/agent` |
 | `-v` / `--verbose` | print each rsync command and its output |
@@ -52,6 +53,59 @@ Host-local state is deliberately never touched: `sessions/`, `npm/`,
 Multiple hosts are accepted: `pi-sync a b c`. Exits non-zero if any host is
 unreachable or any transfer fails.
 
+## Host preflight
+
+Each host gets one ssh probe that reports reachability and pi's location in the
+same round trip.
+
+If pi is missing, pi-sync hands the terminal to pi's own installer
+(`curl -fsSL https://pi.dev/install.sh | sh`), which keeps full control: its
+prompts (its install/uninstall/do-nothing menu, a Node.js install, a sudo
+password) work normally, and the sync continues once it exits. pi-sync does not
+add a confirmation of its own, because the installer already asks. Without a
+terminal it runs unattended under `--install`, stays quiet otherwise, and
+`--dry-run` never installs anything.
+
+The installer's exit status is not treated as proof: its "do nothing" choice
+exits 0, so the host is re-probed afterwards and reported honestly.
+
+**A host without pi is skipped** — copying into a host that has never run pi is
+not useful and usually fails anyway, since there is no agent directory to copy
+into. That covers an installer run that installed nothing, a failed install, and
+a non-interactive run without `--install`; a skipped host makes the run exit
+non-zero. After a successful install pi-sync creates the agent directory,
+because rsync will not create intermediate directories on its own.
+
+The probe checks `command -v pi` plus the usual install locations
+(`~/.local/bin`, `~/.pi/bin`, `~/.pi/agent/bin`, linuxbrew, homebrew,
+`/usr/local/bin`), because a non-interactive ssh session does not source the
+host's shell init — on a linuxbrew host `command -v pi` alone misses it.
+
+## Shell completions
+
+Host arguments complete from `~/.ssh/config`, following `Include` directives and
+skipping wildcard entries:
+
+```bash
+# bash
+_PI_SYNC_COMPLETE=bash_source pi-sync > ~/.pi-sync-complete.bash
+echo 'source ~/.pi-sync-complete.bash' >> ~/.bashrc
+
+# zsh
+_PI_SYNC_COMPLETE=zsh_source pi-sync > ~/.pi-sync-complete.zsh
+echo 'source ~/.pi-sync-complete.zsh' >> ~/.zshrc
+
+# fish (config.fish)
+_PI_SYNC_COMPLETE=fish_source pi-sync | source
+```
+
+Writing the script out (rather than `eval "$(_PI_SYNC_COMPLETE=bash_source pi-sync)"`
+on every shell start) keeps shell startup fast, since the eval form runs the
+binary each time. PowerShell works the same way via `powershell_source`.
+
+Completions are read from the config at completion time, so new hosts appear
+without regenerating anything.
+
 ## Caveats
 
 - `settings.json` is machine-written by pi (`lastChangelogVersion` bumps, UI

{pi_sync_cli-0.1.0 → pi_sync_cli-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pi-sync-cli"
-version = "0.1.0"
+version = "0.2.0"
 description = "Sync pi agent config and extensions between hosts over rsync"
 readme = "README.md"
 requires-python = ">=3.10"

pi_sync_cli-0.2.0/pyrightconfig.json

@@ -0,0 +1,5 @@
+{
+  "venvPath": ".",
+  "venv": ".venv",
+  "include": ["src", "tests"]
+}

{pi_sync_cli-0.1.0 → pi_sync_cli-0.2.0}/src/pi_sync/cli.py

@@ -14,12 +14,29 @@ from __future__ import annotations
 
 import os
 import subprocess
+import sys
 from collections.abc import Sequence
 from pathlib import Path
 
 import click
+from click.shell_completion import CompletionItem
 
 DEFAULT_AGENT_DIR = "~/.pi/agent"
+SSH_CONFIG = "~/.ssh/config"
+PI_INSTALL_CMD = "curl -fsSL https://pi.dev/install.sh | sh"
+# One ssh round trip answers both "is it reachable" and "where is pi".
+PI_PROBE = """\
+found="$(command -v pi 2>/dev/null)"
+if [ -z "$found" ]; then
+  for candidate in "$HOME/.local/bin/pi" "$HOME/.pi/bin/pi" \\
+      "$HOME/.linuxbrew/bin/pi" /home/linuxbrew/.linuxbrew/bin/pi \\
+      "$HOME/.pi/agent/bin/pi" /opt/homebrew/bin/pi /usr/local/bin/pi; do
+    if [ -x "$candidate" ]; then found="$candidate"; break; fi
+  done
+fi
+if [ -n "$found" ]; then echo "PI:$found"; fi
+exit 0
+"""
 DIRECTORY_ITEMS = frozenset({"extensions"})
 GROUPS: dict[str, tuple[str, ...]] = {
     "config": ("models.json", "settings.json"),
@@ -36,6 +53,56 @@ def local_agent_dir(override: str | None = None) -> Path:
     return Path(raw).expanduser()
 
 
+def ssh_hosts(
+    config: str = SSH_CONFIG, _seen: frozenset[str] = frozenset()
+) -> list[str]:
+    """Host aliases from an ssh config, following Include and skipping wildcards."""
+    path = Path(config).expanduser()
+    if not path.is_file():
+        return []
+    resolved = str(path.resolve())
+    if resolved in _seen:
+        return []
+    seen = _seen | {resolved}
+    hosts: list[str] = []
+    for raw_line in path.read_text(errors="replace").splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith("#"):
+            continue
+        parts = line.split(None, 1)
+        if len(parts) < 2:
+            continue
+        keyword, rest = parts[0].lower(), parts[1].strip()
+        if keyword == "host":
+            for token in rest.split():
+                wildcard = "*" in token or "?" in token or token.startswith("!")
+                if not wildcard and token not in hosts:
+                    hosts.append(token)
+        elif keyword == "include":
+            for pattern in rest.split():
+                target = Path(pattern).expanduser()
+                if not target.is_absolute():
+                    target = Path.home() / ".ssh" / target
+                for included in sorted(target.parent.glob(target.name)):
+                    hosts += [
+                        h for h in ssh_hosts(str(included), seen) if h not in hosts
+                    ]
+    return hosts
+
+
+def complete_target(
+    ctx: click.Context, param: click.Parameter, incomplete: str
+) -> list[CompletionItem]:
+    """Complete the host part of a target from the user's ssh config."""
+    prefix = incomplete.rpartition("@")[2]
+    lead = incomplete[: len(incomplete) - len(prefix)] if prefix else incomplete
+    return [
+        CompletionItem(f"{lead}{host}")
+        for host in ssh_hosts()
+        if host.startswith(prefix)
+    ]
+
+
 def select_items(groups: set[str]) -> list[str]:
     return [item for group in GROUP_ORDER if group in groups for item in GROUPS[group]]
 
@@ -67,8 +134,10 @@ def rsync_argv(
     return argv
 
 
-def run_cmd(argv: list[str]) -> subprocess.CompletedProcess[str]:
-    return subprocess.run(argv, capture_output=True, text=True)
+def run_cmd(
+    argv: list[str], input_text: str | None = None, capture: bool = True
+) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(argv, capture_output=capture, text=True, input=input_text)
 
 
 def summarize(output: str) -> tuple[int, int]:
@@ -82,13 +151,81 @@ def summarize(output: str) -> tuple[int, int]:
     return transferred, deleted
 
 
-def check_ssh(target: str) -> str | None:
-    """Return an error message if the host is unreachable, else None."""
-    proc = run_cmd(["ssh", "-o", "ConnectTimeout=10", target, "true"])
-    if proc.returncode == 0:
-        return None
-    detail = (proc.stderr or proc.stdout or "ssh failed").strip().splitlines()
-    return detail[0] if detail else "ssh failed"
+def probe_host(target: str) -> tuple[str | None, str | None]:
+    """Return (error, pi path): error is set when the host is unreachable."""
+    proc = run_cmd(["ssh", "-o", "ConnectTimeout=10", target, "sh -s"], PI_PROBE)
+    if proc.returncode != 0:
+        detail = (proc.stderr or proc.stdout or "ssh failed").strip().splitlines()
+        return (detail[0] if detail else "ssh failed"), None
+    for line in proc.stdout.splitlines():
+        if line.startswith("PI:"):
+            return None, line.removeprefix("PI:").strip()
+    return None, None
+
+
+def install_pi(target: str) -> str | None:
+    """Run pi's installer on the host. Returns an error message, or None on success.
+
+    Attached to a terminal the installer streams straight through and gets a
+    remote tty, so its prompts are visible and answerable: capturing them would
+    leave the user staring at a silent, unanswerable hang. Unattended, output is
+    captured for the failure summary and stdin is closed so a prompt fails fast
+    instead of blocking forever.
+
+    The installer's exit status is not proof of anything: its "do nothing" menu
+    choice exits 0 without installing, so the host is re-probed afterwards.
+    """
+    interactive = sys.stdin.isatty()
+    argv = ["ssh", *(["-t"] if interactive else []), target, PI_INSTALL_CMD]
+    if interactive:
+        proc = run_cmd(argv, capture=False)
+        failure = f"installer exited {proc.returncode}" if proc.returncode else None
+    else:
+        proc = run_cmd(argv, input_text="")
+        if proc.returncode:
+            detail = ((proc.stderr or proc.stdout) or "").strip().splitlines()
+            failure = detail[-1] if detail else f"installer exited {proc.returncode}"
+        else:
+            failure = None
+    if failure:
+        return failure
+    _, pi_path = probe_host(target)
+    if pi_path is None:
+        return "installer exited without installing pi (its menu needs 'y')"
+    return None
+
+
+def ensure_pi(target: str, assume_yes: bool, remote_dir: str) -> bool:
+    """Make sure the host has pi. Returns False when the host must be skipped.
+
+    Copying into a host without pi is not useful and usually fails outright,
+    since the agent directory does not exist there yet.
+
+    Interactively the installer owns the decision: it has its own
+    install/uninstall/do-nothing menu, so prompting a second time here would
+    only add a redundant question before the one that counts.
+    """
+    interactive = sys.stdin.isatty()
+    if not interactive and not assume_yes:
+        click.secho(
+            "  pi not installed — skipping (pass --install to add it)", fg="yellow"
+        )
+        return False
+    if interactive:
+        click.secho(
+            "  handing over to pi's installer — the sync continues when it exits"
+        )
+    else:
+        click.secho("  running pi's installer (unattended)")
+    error = install_pi(target)
+    if error:
+        click.secho(f"  {error} — skipping host", fg="red")
+        return False
+    click.secho("  pi installed; continuing with the sync", fg="green")
+    # A fresh install has never run, so the agent dir may not exist yet and
+    # rsync will not create intermediate directories for us.
+    run_cmd(["ssh", target, f"mkdir -p {remote_dir}"])
+    return True
 
 
 def sync_host(
@@ -103,7 +240,6 @@ def sync_host(
     verbose: bool,
     excludes: Sequence[str] = (),
 ) -> bool:
-    click.secho(f"→ {target}", bold=True)
     ok = True
     for rel in items:
         if not pull and not (local_dir / rel).exists():
@@ -148,7 +284,13 @@ def sync_host(
 
 
 @click.command(context_settings={"help_option_names": ["-h", "--help"]})
-@click.argument("targets", nargs=-1, required=True, metavar="[USER@]HOST...")
+@click.argument(
+    "targets",
+    nargs=-1,
+    required=True,
+    metavar="[USER@]HOST...",
+    shell_complete=complete_target,
+)
 @click.option(
     "--all", "all_", is_flag=True, help="Sync config and extensions (the default)."
 )
@@ -179,6 +321,12 @@ def sync_host(
     metavar="PATTERN",
     help="rsync exclude pattern, e.g. '*/logs/*' (repeatable).",
 )
+@click.option(
+    "--install",
+    "install_",
+    is_flag=True,
+    help="Install pi on hosts that lack it, without prompting.",
+)
 @click.option(
     "--local-dir",
     default=None,
@@ -203,6 +351,7 @@ def main(
     delete_: bool,
     dry_run: bool,
     excludes: tuple[str, ...],
+    install_: bool,
     local_dir: str | None,
     remote_dir: str,
     verbose: bool,
@@ -242,11 +391,20 @@ def main(
     failed = False
     for raw_target in targets:
         target = raw_target.rstrip(":")
-        error = check_ssh(target)
+        error, pi_path = probe_host(target)
         if error:
             failed = True
             click.secho(f"→ {target}\n  unreachable: {error}", fg="red")
             continue
+        click.secho(f"→ {target}", bold=True)
+        if pi_path is None:
+            if dry_run:
+                click.secho("  pi not installed — nothing would be synced", fg="yellow")
+                failed = True
+                continue
+            if not ensure_pi(target, install_, remote_dir):
+                failed = True
+                continue
         if not sync_host(
             target,
             items,

pi_sync_cli-0.2.0/tests/test_cli.py

@@ -0,0 +1,552 @@
+"""Tests for pi-sync.
+
+Covers flag→item selection, rsync argv construction, ssh-config host
+completion, and the per-host pi probe/install path. No ssh or rsync process is
+ever executed.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+import click
+import pytest
+from click.testing import CliRunner
+
+from pi_sync import cli
+
+
+class FakeRun:
+    """Records every command; replays canned itemize output for rsync."""
+
+    def __init__(
+        self,
+        rsync_stdout: str = ">f+++++++ models.json\n",
+        rsync_rc: int = 0,
+        ssh_rc: int = 0,
+        pi_path: str | None = "/usr/bin/pi",
+        install_rc: int = 0,
+        install_installs: bool = True,
+    ):
+        self.calls: list[list[str]] = []
+        self.inputs: list[str | None] = []
+        self.captures: list[bool] = []
+        self.rsync_stdout = rsync_stdout
+        self.rsync_rc = rsync_rc
+        self.ssh_rc = ssh_rc
+        self.pi_path = pi_path
+        self.install_rc = install_rc
+        self.install_installs = install_installs
+        self.installed = False
+
+    def __call__(
+        self, argv: list[str], input_text: str | None = None, capture: bool = True
+    ) -> subprocess.CompletedProcess[str]:
+        self.calls.append(argv)
+        self.inputs.append(input_text)
+        self.captures.append(capture)
+        if argv[0] != "ssh":
+            return subprocess.CompletedProcess(
+                argv, self.rsync_rc, self.rsync_stdout, ""
+            )
+        if any("install.sh" in arg for arg in argv):
+            if self.install_rc == 0:
+                # a real installer exits 0 even when the user picks "do nothing"
+                self.installed = self.install_installs
+            stderr = "" if self.install_rc == 0 else "curl: (22) installer failed"
+            return subprocess.CompletedProcess(
+                argv, self.install_rc, "installed\n", stderr
+            )
+        if self.ssh_rc:
+            return subprocess.CompletedProcess(
+                argv, self.ssh_rc, "", "ssh: connect failed"
+            )
+        path = self.pi_path or ("/usr/local/bin/pi" if self.installed else None)
+        probe = f"PI:{path}\n" if path else ""
+        return subprocess.CompletedProcess(argv, 0, probe, "")
+
+
+class _TtyStdin:
+    """Stand-in for an interactive terminal."""
+
+    def isatty(self) -> bool:
+        return True
+
+
+@pytest.fixture
+def fake(monkeypatch: pytest.MonkeyPatch) -> FakeRun:
+    runner = FakeRun()
+    monkeypatch.setattr(cli, "run_cmd", runner)
+    return runner
+
+
+@pytest.fixture
+def agent_dir(tmp_path: Path) -> Path:
+    """A fake local agent dir with every syncable item present."""
+    (tmp_path / "models.json").write_text("{}")
+    (tmp_path / "settings.json").write_text("{}")
+    (tmp_path / "auth.json").write_text("{}")
+    (tmp_path / "extensions").mkdir()
+    return tmp_path
+
+
+def rsync_calls(fake: FakeRun) -> list[list[str]]:
+    return [call for call in fake.calls if call[0] == "rsync"]
+
+
+def sources(fake: FakeRun) -> list[str]:
+    """The local-side path of each rsync call, for push invocations."""
+    return [Path(call[-2]).name for call in rsync_calls(fake)]
+
+
+@pytest.mark.parametrize(
+    ("groups", "expected"),
+    [
+        ({"config"}, ["models.json", "settings.json"]),
+        ({"extensions"}, ["extensions"]),
+        ({"auth"}, ["auth.json"]),
+        ({"config", "extensions"}, ["models.json", "settings.json", "extensions"]),
+        ({"config", "auth"}, ["models.json", "settings.json", "auth.json"]),
+        (set(), []),
+    ],
+)
+def test_select_items(groups: set[str], expected: list[str]) -> None:
+    assert cli.select_items(groups) == expected
+
+
+@pytest.mark.parametrize(
+    ("argv_kwargs", "expected"),
+    [
+        ({}, ["rsync", "-az", "-i", "/a/models.json", "host:~/.pi/agent/models.json"]),
+        (
+            {"pull": True},
+            ["rsync", "-az", "-i", "host:~/.pi/agent/models.json", "/a/models.json"],
+        ),
+        (
+            {"dry_run": True},
+            [
+                "rsync",
+                "-az",
+                "-i",
+                "-n",
+                "/a/models.json",
+                "host:~/.pi/agent/models.json",
+            ],
+        ),
+        (
+            {"delete": True},
+            ["rsync", "-az", "-i", "/a/models.json", "host:~/.pi/agent/models.json"],
+        ),
+    ],
+)
+def test_rsync_argv_files(argv_kwargs: dict, expected: list[str]) -> None:
+    assert (
+        cli.rsync_argv("models.json", "host", Path("/a"), "~/.pi/agent", **argv_kwargs)
+        == expected
+    )
+
+
+def test_rsync_argv_directory_gets_trailing_slashes() -> None:
+    argv = cli.rsync_argv("extensions", "host", Path("/a"), "~/.pi/agent")
+    assert argv[-2:] == ["/a/extensions/", "host:~/.pi/agent/extensions/"]
+
+
+def test_rsync_argv_delete_only_for_directories() -> None:
+    assert "--delete-during" in cli.rsync_argv(
+        "extensions", "host", Path("/a"), "~/.pi/agent", delete=True
+    )
+    assert "--delete-during" not in cli.rsync_argv(
+        "models.json", "host", Path("/a"), "~/.pi/agent", delete=True
+    )
+
+
+def test_rsync_argv_excludes() -> None:
+    argv = cli.rsync_argv(
+        "extensions", "host", Path("/a"), "~/.pi/agent", excludes=("*/logs/*",)
+    )
+    assert "--exclude=*/logs/*" in argv
+
+
+def test_exclude_flag_passes_through(fake: FakeRun, agent_dir: Path) -> None:
+    CliRunner().invoke(
+        cli.main,
+        ["--extensions", "-x", "*/logs/*", "--local-dir", str(agent_dir), "host"],
+    )
+    calls = rsync_calls(fake)
+    assert calls and all("--exclude=*/logs/*" in call for call in calls)
+
+
+def test_remote_dir_trailing_slash_is_not_doubled() -> None:
+    argv = cli.rsync_argv("models.json", "host", Path("/a"), "~/.pi/agent/")
+    assert argv[-1] == "host:~/.pi/agent/models.json"
+
+
+@pytest.mark.parametrize(
+    ("flags", "expected"),
+    [
+        ([], ["models.json", "settings.json", "extensions"]),
+        (["--all"], ["models.json", "settings.json", "extensions"]),
+        (["--config"], ["models.json", "settings.json"]),
+        (["--extensions"], ["extensions"]),
+        (["--config", "--auth"], ["models.json", "settings.json", "auth.json"]),
+        (
+            ["--all", "--auth"],
+            ["models.json", "settings.json", "extensions", "auth.json"],
+        ),
+    ],
+)
+def test_flags_select_items(
+    fake: FakeRun, agent_dir: Path, flags: list[str], expected: list[str]
+) -> None:
+    result = CliRunner().invoke(
+        cli.main, [*flags, "--local-dir", str(agent_dir), "host"]
+    )
+    assert result.exit_code == 0, result.output
+    assert sources(fake) == expected
+
+
+def test_ssh_probe_runs_before_rsync(fake: FakeRun, agent_dir: Path) -> None:
+    CliRunner().invoke(cli.main, ["--local-dir", str(agent_dir), "host"])
+    assert fake.calls[0] == ["ssh", "-o", "ConnectTimeout=10", "host", "sh -s"]
+    assert fake.calls[1][0] == "rsync"
+    # the probe script is piped over stdin so it works under fish/csh too
+    assert "command -v pi" in (fake.inputs[0] or "")
+
+
+def test_missing_local_item_is_skipped(fake: FakeRun, tmp_path: Path) -> None:
+    (tmp_path / "models.json").write_text("{}")
+    result = CliRunner().invoke(
+        cli.main, ["--all", "--local-dir", str(tmp_path), "host"]
+    )
+    assert result.exit_code == 0
+    assert sources(fake) == ["models.json"]
+    assert "skipped" in result.output
+
+
+def test_pull_does_not_require_local_files(fake: FakeRun, tmp_path: Path) -> None:
+    result = CliRunner().invoke(
+        cli.main, ["--all", "--pull", "--local-dir", str(tmp_path), "host"]
+    )
+    assert result.exit_code == 0
+    assert sources(fake) == [
+        "models.json",
+        "settings.json",
+        "extensions",
+    ]  # remote paths, pulled from
+
+
+def test_default_remote_dir(fake: FakeRun, agent_dir: Path) -> None:
+    CliRunner().invoke(cli.main, ["--config", "--local-dir", str(agent_dir), "host"])
+    assert all("host:~/.pi/agent/" in call[-1] for call in rsync_calls(fake))
+
+
+def test_remote_dir_override(fake: FakeRun, agent_dir: Path) -> None:
+    CliRunner().invoke(
+        cli.main,
+        ["--config", "--local-dir", str(agent_dir), "--remote-dir", "/srv/pi", "host"],
+    )
+    assert all("host:/srv/pi/" in call[-1] for call in rsync_calls(fake))
+
+
+def test_trailing_colon_is_stripped(fake: FakeRun, agent_dir: Path) -> None:
+    CliRunner().invoke(
+        cli.main, ["--config", "--local-dir", str(agent_dir), "sayan@host:"]
+    )
+    assert all(call[-1].startswith("sayan@host:") for call in rsync_calls(fake))
+
+
+def test_multiple_hosts(fake: FakeRun, agent_dir: Path) -> None:
+    CliRunner().invoke(cli.main, ["--config", "--local-dir", str(agent_dir), "a", "b"])
+    targets = {call[-1].split(":")[0] for call in rsync_calls(fake)}
+    assert targets == {"a", "b"}
+
+
+def test_auth_warns_about_secrets(fake: FakeRun, agent_dir: Path) -> None:
+    result = CliRunner().invoke(
+        cli.main, ["--auth", "--local-dir", str(agent_dir), "host"]
+    )
+    assert "API keys" in result.output
+
+
+def test_unreachable_host_exits_nonzero(
+    monkeypatch: pytest.MonkeyPatch, agent_dir: Path
+) -> None:
+    monkeypatch.setattr(cli, "run_cmd", FakeRun(ssh_rc=255))
+    result = CliRunner().invoke(
+        cli.main, ["--config", "--local-dir", str(agent_dir), "host"]
+    )
+    assert result.exit_code == 1
+    assert "unreachable" in result.output
+
+
+def test_rsync_failure_exits_nonzero(
+    monkeypatch: pytest.MonkeyPatch, agent_dir: Path
+) -> None:
+    monkeypatch.setattr(cli, "run_cmd", FakeRun(rsync_rc=23))
+    result = CliRunner().invoke(
+        cli.main, ["--config", "--local-dir", str(agent_dir), "host"]
+    )
+    assert result.exit_code == 1
+    assert "FAILED" in result.output
+
+
+@pytest.mark.parametrize(
+    ("output", "expected"),
+    [
+        (">f+++++++ a\n>f+++++++ b\n", (2, 0)),
+        ("*deleting stale.txt\n>f+++++++++ new.txt\n", (1, 1)),
+        (".d..t...... extensions/\n", (0, 0)),
+        ("", (0, 0)),
+    ],
+)
+def test_summarize(output: str, expected: tuple[int, int]) -> None:
+    assert cli.summarize(output) == expected
+
+
+def test_local_dir_env_override(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    monkeypatch.setenv("PI_CODING_AGENT_DIR", str(tmp_path))
+    assert cli.local_agent_dir() == tmp_path
+    assert cli.local_agent_dir("/explicit") == Path("/explicit")
+
+
+def ssh_probe_calls(fake: FakeRun) -> list[list[str]]:
+    """ssh calls that are the pi probe (not the installer)."""
+    return [
+        c for c in fake.calls if c[0] == "ssh" and not any("install.sh" in a for a in c)
+    ]
+
+
+def install_calls(fake: FakeRun) -> list[list[str]]:
+    return [c for c in fake.calls if any("install.sh" in a for a in c)]
+
+
+class TestSshHosts:
+    def test_single_host(self, tmp_path: Path) -> None:
+        cfg = tmp_path / "config"
+        cfg.write_text("Host tinfoil\n  HostName tinfoil.example\n")
+        assert cli.ssh_hosts(str(cfg)) == ["tinfoil"]
+
+    def test_multiple_tokens_and_trailing_whitespace(self, tmp_path: Path) -> None:
+        cfg = tmp_path / "config"
+        cfg.write_text("Host svalbard \nHost a b\n")
+        assert cli.ssh_hosts(str(cfg)) == ["svalbard", "a", "b"]
+
+    def test_wildcards_and_negations_skipped(self, tmp_path: Path) -> None:
+        cfg = tmp_path / "config"
+        cfg.write_text(
+            "Host *.orb.local\nHost api.example.com !api.internal\nHost real\n"
+        )
+        assert cli.ssh_hosts(str(cfg)) == ["api.example.com", "real"]
+
+    def test_directives_are_case_insensitive(self, tmp_path: Path) -> None:
+        cfg = tmp_path / "config"
+        cfg.write_text("HOST upper\nhost lower\n")
+        assert cli.ssh_hosts(str(cfg)) == ["upper", "lower"]
+
+    def test_comments_and_blank_lines_ignored(self, tmp_path: Path) -> None:
+        cfg = tmp_path / "config"
+        cfg.write_text("# a comment\n\n   # indented comment\nHost real\n")
+        assert cli.ssh_hosts(str(cfg)) == ["real"]
+
+    def test_non_host_directives_ignored(self, tmp_path: Path) -> None:
+        cfg = tmp_path / "config"
+        cfg.write_text("Host real\n  HostName example.com\n  User bob\n  Port 2222\n")
+        assert cli.ssh_hosts(str(cfg)) == ["real"]
+
+    def test_include_is_followed_and_deduped(self, tmp_path: Path) -> None:
+        extra = tmp_path / "extra_config"
+        extra.write_text("Host orb\nHost tinfoil\n")
+        cfg = tmp_path / "config"
+        cfg.write_text(f"Host tinfoil\nInclude {extra}\n")
+        assert cli.ssh_hosts(str(cfg)) == ["tinfoil", "orb"]
+
+    def test_include_glob(self, tmp_path: Path) -> None:
+        (tmp_path / "conf.d").mkdir()
+        (tmp_path / "conf.d" / "a").write_text("Host alpha\n")
+        (tmp_path / "conf.d" / "b").write_text("Host beta\n")
+        cfg = tmp_path / "config"
+        cfg.write_text(f"Include {tmp_path}/conf.d/*\n")
+        assert cli.ssh_hosts(str(cfg)) == ["alpha", "beta"]
+
+    def test_include_cycle_terminates(self, tmp_path: Path) -> None:
+        cfg = tmp_path / "config"
+        other = tmp_path / "other"
+        cfg.write_text(f"Host one\nInclude {other}\n")
+        other.write_text(f"Host two\nInclude {cfg}\n")
+        assert cli.ssh_hosts(str(cfg)) == ["one", "two"]
+
+    def test_missing_config_is_empty(self, tmp_path: Path) -> None:
+        assert cli.ssh_hosts(str(tmp_path / "nope")) == []
+
+
+class TestCompletion:
+    @staticmethod
+    def complete(incomplete: str) -> list[str]:
+        """Run the completion callback the way click would."""
+        ctx = click.Context(cli.main)
+        items = cli.complete_target(ctx, cli.main.params[0], incomplete)
+        return [item.value for item in items]
+
+    def test_completes_matching_hosts(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(
+            cli, "ssh_hosts", lambda *a, **k: ["tinfoil", "zero-frame", "phatboi"]
+        )
+        assert self.complete("t") == ["tinfoil"]
+
+    def test_empty_incomplete_lists_everything(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        monkeypatch.setattr(cli, "ssh_hosts", lambda *a, **k: ["a", "b"])
+        assert self.complete("") == ["a", "b"]
+
+    def test_user_at_prefix_is_preserved(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(cli, "ssh_hosts", lambda *a, **k: ["tinfoil", "zero-frame"])
+        assert self.complete("sayan@zer") == ["sayan@zero-frame"]
+
+
+class TestProbe:
+    def test_reports_pi_path(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(
+            cli, "run_cmd", FakeRun(pi_path="/home/linuxbrew/.linuxbrew/bin/pi")
+        )
+        assert cli.probe_host("host") == (None, "/home/linuxbrew/.linuxbrew/bin/pi")
+
+    def test_reports_missing_pi(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(cli, "run_cmd", FakeRun(pi_path=None))
+        assert cli.probe_host("host") == (None, None)
+
+    def test_reports_unreachable(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setattr(cli, "run_cmd", FakeRun(ssh_rc=255))
+        error, pi_path = cli.probe_host("host")
+        assert error == "ssh: connect failed"
+        assert pi_path is None
+
+
+class TestInstallOffering:
+    def test_no_install_when_pi_present(
+        self, monkeypatch: pytest.MonkeyPatch, agent_dir: Path
+    ) -> None:
+        fake = FakeRun(pi_path="/usr/bin/pi")
+        monkeypatch.setattr(cli, "run_cmd", fake)
+        result = CliRunner().invoke(cli.main, ["--local-dir", str(agent_dir), "host"])
+        assert result.exit_code == 0
+        assert install_calls(fake) == []
+
+    def test_missing_pi_without_tty_skips_host(
+        self, monkeypatch: pytest.MonkeyPatch, agent_dir: Path
+    ) -> None:
+        fake = FakeRun(pi_path=None)
+        monkeypatch.setattr(cli, "run_cmd", fake)
+        result = CliRunner().invoke(cli.main, ["--local-dir", str(agent_dir), "host"])
+        assert result.exit_code == 1
+        assert install_calls(fake) == []
+        assert not any(c[0] == "rsync" for c in fake.calls)
+        assert "--install" in result.output
+
+    def test_interactive_install_needs_no_second_prompt(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """The installer owns the decision; pi-sync must not pre-ask on top of it."""
+        fake = FakeRun(pi_path=None)
+        monkeypatch.setattr(cli, "run_cmd", fake)
+        monkeypatch.setattr(sys, "stdin", _TtyStdin())
+        asked: list[str] = []
+        monkeypatch.setattr(
+            click, "confirm", lambda *a, **k: asked.append("confirm") or False
+        )
+        assert cli.ensure_pi("host", assume_yes=False, remote_dir="~/.pi/agent") is True
+        assert asked == []
+        assert len(install_calls(fake)) == 1
+
+    def test_install_flag_installs_then_syncs(
+        self, monkeypatch: pytest.MonkeyPatch, agent_dir: Path
+    ) -> None:
+        fake = FakeRun(pi_path=None)
+        monkeypatch.setattr(cli, "run_cmd", fake)
+        result = CliRunner().invoke(
+            cli.main, ["--install", "--local-dir", str(agent_dir), "host"]
+        )
+        assert result.exit_code == 0
+        (call,) = install_calls(fake)
+        assert call[-1] == cli.PI_INSTALL_CMD
+        assert "pi installed" in result.output
+        # a fresh install has no agent dir yet, so it is created before rsync
+        assert any("mkdir -p" in arg for c in fake.calls for arg in c)
+        assert any(c[0] == "rsync" for c in fake.calls)
+
+    def test_install_failure_skips_host(
+        self, monkeypatch: pytest.MonkeyPatch, agent_dir: Path
+    ) -> None:
+        fake = FakeRun(pi_path=None, install_rc=22)
+        monkeypatch.setattr(cli, "run_cmd", fake)
+        result = CliRunner().invoke(
+            cli.main, ["--install", "--local-dir", str(agent_dir), "host"]
+        )
+        assert result.exit_code == 1
+        assert "skipping host" in result.output
+        assert not any(c[0] == "rsync" for c in fake.calls)
+
+    def test_installer_that_installs_nothing_skips_host(
+        self, monkeypatch: pytest.MonkeyPatch, agent_dir: Path
+    ) -> None:
+        """The installer exits 0 for its "do nothing" choice; that is not success."""
+        fake = FakeRun(pi_path=None, install_installs=False)
+        monkeypatch.setattr(cli, "run_cmd", fake)
+        result = CliRunner().invoke(
+            cli.main, ["--install", "--local-dir", str(agent_dir), "host"]
+        )
+        assert result.exit_code == 1
+        assert "without installing pi" in result.output
+        assert not any(c[0] == "rsync" for c in fake.calls)
+
+    def test_dry_run_never_installs_anything(
+        self, monkeypatch: pytest.MonkeyPatch, agent_dir: Path
+    ) -> None:
+        fake = FakeRun(pi_path=None)
+        monkeypatch.setattr(cli, "run_cmd", fake)
+        result = CliRunner().invoke(
+            cli.main,
+            ["--install", "--dry-run", "--local-dir", str(agent_dir), "host"],
+        )
+        assert result.exit_code == 1
+        assert install_calls(fake) == []
+        assert not any(c[0] == "rsync" for c in fake.calls)
+
+    def test_interactive_install_streams_and_gets_a_tty(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """The installer prompts on /dev/tty, so its output must not be captured."""
+        fake = FakeRun()
+        monkeypatch.setattr(cli, "run_cmd", fake)
+        monkeypatch.setattr(sys, "stdin", _TtyStdin())
+        assert cli.install_pi("host") is None
+        (call,) = install_calls(fake)
+        assert "-t" in call
+        assert fake.captures[0] is False  # install call streams; the re-probe captures
+
+    def test_unattended_install_captures_and_closes_stdin(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Without a terminal the installer gets EOF instead of blocking on a prompt."""
+        fake = FakeRun()
+        monkeypatch.setattr(cli, "run_cmd", fake)
+        assert cli.install_pi("host") is None
+        (call,) = install_calls(fake)
+        assert "-t" not in call
+        assert fake.inputs[0] == ""
+        assert fake.captures[0] is True
+
+    def test_no_install_attempt_when_unreachable(
+        self, monkeypatch: pytest.MonkeyPatch, agent_dir: Path
+    ) -> None:
+        fake = FakeRun(pi_path=None, ssh_rc=255)
+        monkeypatch.setattr(cli, "run_cmd", fake)
+        result = CliRunner().invoke(
+            cli.main, ["--install", "--local-dir", str(agent_dir), "host"]
+        )
+        assert result.exit_code == 1
+        assert install_calls(fake) == []

{pi_sync_cli-0.1.0 → pi_sync_cli-0.2.0}/uv.lock

@@ -52,7 +52,7 @@ wheels = [
 
 [[package]]
 name = "pi-sync-cli"
-version = "0.1.0"
+version = "0.2.0"
 source = { editable = "." }
 dependencies = [
     { name = "click" },

pi_sync_cli-0.1.0/tests/test_cli.py

@@ -1,270 +0,0 @@
-"""Tests for pi-sync. No ssh or rsync process is ever executed."""
-
-from __future__ import annotations
-
-import subprocess
-from pathlib import Path
-
-import pytest
-from click.testing import CliRunner
-
-from pi_sync import cli
-
-
-class FakeRun:
-    """Records every command; replays canned itemize output for rsync."""
-
-    def __init__(
-        self,
-        rsync_stdout: str = ">f+++++++ models.json\n",
-        rsync_rc: int = 0,
-        ssh_rc: int = 0,
-    ):
-        self.calls: list[list[str]] = []
-        self.rsync_stdout = rsync_stdout
-        self.rsync_rc = rsync_rc
-        self.ssh_rc = ssh_rc
-
-    def __call__(self, argv: list[str]) -> subprocess.CompletedProcess[str]:
-        self.calls.append(argv)
-        if argv[0] == "ssh":
-            return subprocess.CompletedProcess(
-                argv, self.ssh_rc, "", "" if self.ssh_rc == 0 else "ssh: connect failed"
-            )
-        return subprocess.CompletedProcess(argv, self.rsync_rc, self.rsync_stdout, "")
-
-
-@pytest.fixture
-def fake(monkeypatch: pytest.MonkeyPatch) -> FakeRun:
-    runner = FakeRun()
-    monkeypatch.setattr(cli, "run_cmd", runner)
-    return runner
-
-
-@pytest.fixture
-def agent_dir(tmp_path: Path) -> Path:
-    """A fake local agent dir with every syncable item present."""
-    (tmp_path / "models.json").write_text("{}")
-    (tmp_path / "settings.json").write_text("{}")
-    (tmp_path / "auth.json").write_text("{}")
-    (tmp_path / "extensions").mkdir()
-    return tmp_path
-
-
-def rsync_calls(fake: FakeRun) -> list[list[str]]:
-    return [call for call in fake.calls if call[0] == "rsync"]
-
-
-def sources(fake: FakeRun) -> list[str]:
-    """The local-side path of each rsync call, for push invocations."""
-    return [Path(call[-2]).name for call in rsync_calls(fake)]
-
-
-@pytest.mark.parametrize(
-    ("groups", "expected"),
-    [
-        ({"config"}, ["models.json", "settings.json"]),
-        ({"extensions"}, ["extensions"]),
-        ({"auth"}, ["auth.json"]),
-        ({"config", "extensions"}, ["models.json", "settings.json", "extensions"]),
-        ({"config", "auth"}, ["models.json", "settings.json", "auth.json"]),
-        (set(), []),
-    ],
-)
-def test_select_items(groups: set[str], expected: list[str]) -> None:
-    assert cli.select_items(groups) == expected
-
-
-@pytest.mark.parametrize(
-    ("argv_kwargs", "expected"),
-    [
-        ({}, ["rsync", "-az", "-i", "/a/models.json", "host:~/.pi/agent/models.json"]),
-        (
-            {"pull": True},
-            ["rsync", "-az", "-i", "host:~/.pi/agent/models.json", "/a/models.json"],
-        ),
-        (
-            {"dry_run": True},
-            [
-                "rsync",
-                "-az",
-                "-i",
-                "-n",
-                "/a/models.json",
-                "host:~/.pi/agent/models.json",
-            ],
-        ),
-        (
-            {"delete": True},
-            ["rsync", "-az", "-i", "/a/models.json", "host:~/.pi/agent/models.json"],
-        ),
-    ],
-)
-def test_rsync_argv_files(argv_kwargs: dict, expected: list[str]) -> None:
-    assert (
-        cli.rsync_argv("models.json", "host", Path("/a"), "~/.pi/agent", **argv_kwargs)
-        == expected
-    )
-
-
-def test_rsync_argv_directory_gets_trailing_slashes() -> None:
-    argv = cli.rsync_argv("extensions", "host", Path("/a"), "~/.pi/agent")
-    assert argv[-2:] == ["/a/extensions/", "host:~/.pi/agent/extensions/"]
-
-
-def test_rsync_argv_delete_only_for_directories() -> None:
-    assert "--delete-during" in cli.rsync_argv(
-        "extensions", "host", Path("/a"), "~/.pi/agent", delete=True
-    )
-    assert "--delete-during" not in cli.rsync_argv(
-        "models.json", "host", Path("/a"), "~/.pi/agent", delete=True
-    )
-
-
-def test_rsync_argv_excludes() -> None:
-    argv = cli.rsync_argv(
-        "extensions", "host", Path("/a"), "~/.pi/agent", excludes=("*/logs/*",)
-    )
-    assert "--exclude=*/logs/*" in argv
-
-
-def test_exclude_flag_passes_through(fake: FakeRun, agent_dir: Path) -> None:
-    CliRunner().invoke(
-        cli.main,
-        ["--extensions", "-x", "*/logs/*", "--local-dir", str(agent_dir), "host"],
-    )
-    calls = rsync_calls(fake)
-    assert calls and all("--exclude=*/logs/*" in call for call in calls)
-
-
-def test_remote_dir_trailing_slash_is_not_doubled() -> None:
-    argv = cli.rsync_argv("models.json", "host", Path("/a"), "~/.pi/agent/")
-    assert argv[-1] == "host:~/.pi/agent/models.json"
-
-
-@pytest.mark.parametrize(
-    ("flags", "expected"),
-    [
-        ([], ["models.json", "settings.json", "extensions"]),
-        (["--all"], ["models.json", "settings.json", "extensions"]),
-        (["--config"], ["models.json", "settings.json"]),
-        (["--extensions"], ["extensions"]),
-        (["--config", "--auth"], ["models.json", "settings.json", "auth.json"]),
-        (
-            ["--all", "--auth"],
-            ["models.json", "settings.json", "extensions", "auth.json"],
-        ),
-    ],
-)
-def test_flags_select_items(
-    fake: FakeRun, agent_dir: Path, flags: list[str], expected: list[str]
-) -> None:
-    result = CliRunner().invoke(
-        cli.main, [*flags, "--local-dir", str(agent_dir), "host"]
-    )
-    assert result.exit_code == 0, result.output
-    assert sources(fake) == expected
-
-
-def test_ssh_preflight_runs_before_rsync(fake: FakeRun, agent_dir: Path) -> None:
-    CliRunner().invoke(cli.main, ["--local-dir", str(agent_dir), "host"])
-    assert fake.calls[0] == ["ssh", "-o", "ConnectTimeout=10", "host", "true"]
-    assert fake.calls[1][0] == "rsync"
-
-
-def test_missing_local_item_is_skipped(fake: FakeRun, tmp_path: Path) -> None:
-    (tmp_path / "models.json").write_text("{}")
-    result = CliRunner().invoke(
-        cli.main, ["--all", "--local-dir", str(tmp_path), "host"]
-    )
-    assert result.exit_code == 0
-    assert sources(fake) == ["models.json"]
-    assert "skipped" in result.output
-
-
-def test_pull_does_not_require_local_files(fake: FakeRun, tmp_path: Path) -> None:
-    result = CliRunner().invoke(
-        cli.main, ["--all", "--pull", "--local-dir", str(tmp_path), "host"]
-    )
-    assert result.exit_code == 0
-    assert sources(fake) == [
-        "models.json",
-        "settings.json",
-        "extensions",
-    ]  # remote paths, pulled from
-
-
-def test_default_remote_dir(fake: FakeRun, agent_dir: Path) -> None:
-    CliRunner().invoke(cli.main, ["--config", "--local-dir", str(agent_dir), "host"])
-    assert all("host:~/.pi/agent/" in call[-1] for call in rsync_calls(fake))
-
-
-def test_remote_dir_override(fake: FakeRun, agent_dir: Path) -> None:
-    CliRunner().invoke(
-        cli.main,
-        ["--config", "--local-dir", str(agent_dir), "--remote-dir", "/srv/pi", "host"],
-    )
-    assert all("host:/srv/pi/" in call[-1] for call in rsync_calls(fake))
-
-
-def test_trailing_colon_is_stripped(fake: FakeRun, agent_dir: Path) -> None:
-    CliRunner().invoke(
-        cli.main, ["--config", "--local-dir", str(agent_dir), "sayan@host:"]
-    )
-    assert all(call[-1].startswith("sayan@host:") for call in rsync_calls(fake))
-
-
-def test_multiple_hosts(fake: FakeRun, agent_dir: Path) -> None:
-    CliRunner().invoke(cli.main, ["--config", "--local-dir", str(agent_dir), "a", "b"])
-    targets = {call[-1].split(":")[0] for call in rsync_calls(fake)}
-    assert targets == {"a", "b"}
-
-
-def test_auth_warns_about_secrets(fake: FakeRun, agent_dir: Path) -> None:
-    result = CliRunner().invoke(
-        cli.main, ["--auth", "--local-dir", str(agent_dir), "host"]
-    )
-    assert "API keys" in result.output
-
-
-def test_unreachable_host_exits_nonzero(
-    monkeypatch: pytest.MonkeyPatch, agent_dir: Path
-) -> None:
-    monkeypatch.setattr(cli, "run_cmd", FakeRun(ssh_rc=255))
-    result = CliRunner().invoke(
-        cli.main, ["--config", "--local-dir", str(agent_dir), "host"]
-    )
-    assert result.exit_code == 1
-    assert "unreachable" in result.output
-
-
-def test_rsync_failure_exits_nonzero(
-    monkeypatch: pytest.MonkeyPatch, agent_dir: Path
-) -> None:
-    monkeypatch.setattr(cli, "run_cmd", FakeRun(rsync_rc=23))
-    result = CliRunner().invoke(
-        cli.main, ["--config", "--local-dir", str(agent_dir), "host"]
-    )
-    assert result.exit_code == 1
-    assert "FAILED" in result.output
-
-
-@pytest.mark.parametrize(
-    ("output", "expected"),
-    [
-        (">f+++++++ a\n>f+++++++ b\n", (2, 0)),
-        ("*deleting stale.txt\n>f+++++++++ new.txt\n", (1, 1)),
-        (".d..t...... extensions/\n", (0, 0)),
-        ("", (0, 0)),
-    ],
-)
-def test_summarize(output: str, expected: tuple[int, int]) -> None:
-    assert cli.summarize(output) == expected
-
-
-def test_local_dir_env_override(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    monkeypatch.setenv("PI_CODING_AGENT_DIR", str(tmp_path))
-    assert cli.local_agent_dir() == tmp_path
-    assert cli.local_agent_dir("/explicit") == Path("/explicit")