pidriver 0.4.1__tar.gz → 0.4.2__tar.gz

{pidriver-0.4.1 → pidriver-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pidriver
-Version: 0.4.1
+Version: 0.4.2
 Summary: Async Python driver for the pi coding agent (pi --mode rpc), built for isolated, headless project work.
 Project-URL: Homepage, https://github.com/bobuk/pidriver
 Project-URL: Repository, https://github.com/bobuk/pidriver
@@ -543,6 +543,7 @@ session, workspace = await start_repository_task(
     client, "Fix the failing tests", "git+ssh://git@github.com/org/project.git",
     root=Path("/srv/pi-jobs"), job_id="task-123",
     ssh_key=Path("/srv/keys/project_ed25519"),
+    known_hosts=Path("/srv/keys/known_hosts"),  # optional: pin host keys to this file
 )
 # Drain the session's events, then close it before finalizing the workspace.
 async for event in session:
@@ -563,7 +564,10 @@ untrusted requests: the caller must enforce an allowlist. Empty repositories and
 second job with the same ID are rejected. SSH also accepts standard `ssh://` and
 `git@host:path` URLs. The key path (not its contents) is saved by `to_state()` for
 later pushes; the key must still exist then. SSH uses strict host-key checking and
-non-interactive authentication; configure `known_hosts` on the host in advance.
+non-interactive authentication. Pass `known_hosts=Path(...)` to pin host keys to that
+file alone (`UserKnownHostsFile=<file>`, `GlobalKnownHostsFile=/dev/null`; the path is
+saved by `to_state()` too) — useful in containers where ssh's own `~/.ssh` isn't yours
+to manage; otherwise configure ssh's default `known_hosts` on the host in advance.
 
 ## Workspace jail
 

{pidriver-0.4.1 → pidriver-0.4.2}/README.md

@@ -517,6 +517,7 @@ session, workspace = await start_repository_task(
     client, "Fix the failing tests", "git+ssh://git@github.com/org/project.git",
     root=Path("/srv/pi-jobs"), job_id="task-123",
     ssh_key=Path("/srv/keys/project_ed25519"),
+    known_hosts=Path("/srv/keys/known_hosts"),  # optional: pin host keys to this file
 )
 # Drain the session's events, then close it before finalizing the workspace.
 async for event in session:
@@ -537,7 +538,10 @@ untrusted requests: the caller must enforce an allowlist. Empty repositories and
 second job with the same ID are rejected. SSH also accepts standard `ssh://` and
 `git@host:path` URLs. The key path (not its contents) is saved by `to_state()` for
 later pushes; the key must still exist then. SSH uses strict host-key checking and
-non-interactive authentication; configure `known_hosts` on the host in advance.
+non-interactive authentication. Pass `known_hosts=Path(...)` to pin host keys to that
+file alone (`UserKnownHostsFile=<file>`, `GlobalKnownHostsFile=/dev/null`; the path is
+saved by `to_state()` too) — useful in containers where ssh's own `~/.ssh` isn't yours
+to manage; otherwise configure ssh's default `known_hosts` on the host in advance.
 
 ## Workspace jail
 

{pidriver-0.4.1 → pidriver-0.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pidriver"
-version = "0.4.1"
+version = "0.4.2"
 description = "Async Python driver for the pi coding agent (pi --mode rpc), built for isolated, headless project work."
 readme = "README.md"
 license = { text = "MIT" }

{pidriver-0.4.1 → pidriver-0.4.2}/src/pidriver/__init__.py

@@ -123,7 +123,7 @@ from .supervisor import PiInstanceSupervisor
 from .usage import UsageTotals
 from .workspace import ProjectDir, list_candidate_projects, list_projects, resolve_project
 
-__version__ = "0.4.1"
+__version__ = "0.4.2"
 
 __all__ = [
     "__version__",

{pidriver-0.4.1 → pidriver-0.4.2}/src/pidriver/repository.py

@@ -21,11 +21,17 @@ class GitRepositoryWorkspace:
     """Isolated clone and worktree; publishing requires an explicit merge()."""
 
     def __init__(
-        self, workspace: StagedWorkspace, *, branch: str, ssh_key: Path | None = None
+        self,
+        workspace: StagedWorkspace,
+        *,
+        branch: str,
+        ssh_key: Path | None = None,
+        known_hosts: Path | None = None,
     ) -> None:
         self.workspace = workspace
         self.branch = branch
         self.ssh_key = ssh_key
+        self.known_hosts = known_hosts
 
     @property
     def path(self) -> Path:
@@ -49,7 +55,7 @@ class GitRepositoryWorkspace:
             "origin",
             f"HEAD:refs/heads/{self.branch}",
             check=False,
-            env=_ssh_env(self.ssh_key),
+            env=_ssh_env(self.ssh_key, self.known_hosts),
         )
         if push.returncode != 0:
             raise MergeConflict(
@@ -76,6 +82,7 @@ class GitRepositoryWorkspace:
             "workspace": self.workspace.to_state(),
             "branch": self.branch,
             "ssh_key": str(self.ssh_key) if self.ssh_key is not None else None,
+            "known_hosts": str(self.known_hosts) if self.known_hosts is not None else None,
         }
 
     @classmethod
@@ -84,41 +91,70 @@ class GitRepositoryWorkspace:
         if not isinstance(workspace, dict):
             raise StagingError("invalid repository workspace state")
         key = state.get("ssh_key")
+        known_hosts = state.get("known_hosts")
         return cls(
             StagedWorkspace.from_state(workspace),
             branch=str(state["branch"]),
             ssh_key=Path(str(key)) if key is not None else None,
+            known_hosts=Path(str(known_hosts)) if known_hosts is not None else None,
         )
 
 
-def _ssh_env(ssh_key: Path | None) -> dict[str, str] | None:
-    if ssh_key is None:
+def _known_hosts_file(known_hosts: Path | None) -> Path | None:
+    if known_hosts is None:
         return None
-    key = Path(ssh_key).expanduser()
-    if not key.is_file():
-        raise StagingError(f"SSH key is not a file: {key}")
+    path = Path(known_hosts).expanduser().resolve()
+    if not path.is_file():
+        raise StagingError(f"known_hosts is not a file: {path}")
+    if any(ch.isspace() for ch in str(path)):
+        # ssh reads UserKnownHostsFile as a whitespace-separated list of files.
+        raise StagingError(f"known_hosts path must not contain whitespace: {path}")
+    return path
+
+
+def _ssh_env(ssh_key: Path | None, known_hosts: Path | None = None) -> dict[str, str] | None:
+    """Git's environment for SSH remotes: the given key only, strict host-key checking against the
+    given known_hosts file only (else ssh's defaults), never a prompt. None: Git's own defaults."""
+    if ssh_key is None and known_hosts is None:
+        return None
+    command = ["ssh"]
+    if ssh_key is not None:
+        key = Path(ssh_key).expanduser()
+        if not key.is_file():
+            raise StagingError(f"SSH key is not a file: {key}")
+        command += ["-i", shlex.quote(str(key.resolve())), "-o", "IdentitiesOnly=yes"]
+    command += ["-o", "BatchMode=yes", "-o", "StrictHostKeyChecking=yes"]
+    pinned = _known_hosts_file(known_hosts)
+    if pinned is not None:
+        command += [
+            "-o", f"UserKnownHostsFile={shlex.quote(str(pinned))}",
+            "-o", "GlobalKnownHostsFile=/dev/null",
+        ]
     return {
         **os.environ,
-        "GIT_SSH_COMMAND": (
-            f"ssh -i {shlex.quote(str(key.resolve()))} "
-            "-o IdentitiesOnly=yes -o BatchMode=yes -o StrictHostKeyChecking=yes"
-        ),
+        "GIT_SSH_COMMAND": " ".join(command),
         "GIT_SSH_VARIANT": "ssh",
         "GIT_TERMINAL_PROMPT": "0",
     }
 
 
 def stage_repository(
-    url: str, *, root: Path, job_id: str, ssh_key: Path | None = None
+    url: str,
+    *,
+    root: Path,
+    job_id: str,
+    ssh_key: Path | None = None,
+    known_hosts: Path | None = None,
 ) -> GitRepositoryWorkspace:
     """Clone a trusted URL into root/job_id and make an isolated pi worktree.
 
     Repository URLs must be selected by the host, not supplied by untrusted users.
-    Git credentials are inherited from the host. Origin stays unchanged until merge().
+    Git credentials are inherited from the host unless ``ssh_key`` is given; ``known_hosts``
+    pins the SSH host keys to that file alone. Origin stays unchanged until merge().
     """
     if not job_id or job_id != Path(job_id).name or job_id in (".", "..") or "\\" in job_id:
         raise StagingError(f"invalid job_id: {job_id!r}")
-    ssh_env = _ssh_env(ssh_key)
+    ssh_env = _ssh_env(ssh_key, known_hosts)
     root = Path(root).resolve()
     job = root / job_id
     if job.exists():
@@ -146,6 +182,7 @@ def stage_repository(
             workspace,
             branch=branch,
             ssh_key=Path(ssh_key).expanduser().resolve() if ssh_key is not None else None,
+            known_hosts=_known_hosts_file(known_hosts),
         )
     except BaseException:
         shutil.rmtree(job, ignore_errors=True)
@@ -160,6 +197,7 @@ async def start_repository_task(
     root: Path,
     job_id: str,
     ssh_key: Path | None = None,
+    known_hosts: Path | None = None,
 ) -> tuple[PiSession, GitRepositoryWorkspace]:
     """Clone, stage and start pi; return session and durable workspace.
 
@@ -167,7 +205,12 @@ async def start_repository_task(
     when approval can happen after a host restart.
     """
     workspace = await asyncio.to_thread(
-        stage_repository, url, root=root, job_id=job_id, ssh_key=ssh_key
+        stage_repository,
+        url,
+        root=root,
+        job_id=job_id,
+        ssh_key=ssh_key,
+        known_hosts=known_hosts,
     )
     try:
         session = await client.start(task, cwd=workspace.path)

{pidriver-0.4.1 → pidriver-0.4.2}/tests/test_repository.py

@@ -120,6 +120,79 @@ def test_ssh_key_used_for_clone_and_push_after_restore(
     ws.cleanup()
 
 
+def test_known_hosts_pins_clone_and_push_after_restore(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    import pidriver.repository as repository
+    import pidriver.staging as staging
+
+    bare = remote(tmp_path)
+    key = tmp_path / "id_ed25519"
+    key.write_text("fake private key")
+    pinned = tmp_path / "known_hosts"
+    pinned.write_text("example.invalid ssh-ed25519 AAAA\n")
+    real_run = subprocess.run
+    commands: list[str] = []
+
+    def capture(argv: list[str], **kwargs: Any) -> subprocess.CompletedProcess[str]:
+        if "clone" in argv:
+            commands.append(kwargs["env"]["GIT_SSH_COMMAND"])
+            argv = [*argv[:3], str(bare), argv[4]]
+        elif "push" in argv:
+            commands.append(kwargs["env"]["GIT_SSH_COMMAND"])
+        return real_run(argv, **kwargs)
+
+    monkeypatch.setattr(repository.subprocess, "run", capture)
+    monkeypatch.setattr(staging.subprocess, "run", capture)
+    ws = stage_repository(
+        "git@example.invalid:project.git",
+        root=tmp_path / "jobs",
+        job_id="pinned-1",
+        ssh_key=key,
+        known_hosts=pinned,
+    )
+    (ws.path / "a.txt").write_text("pinned\n")
+    state = ws.to_state()
+    assert state["known_hosts"] == str(pinned.resolve())
+    GitRepositoryWorkspace.from_state(state).merge()
+    assert git(bare, "show", "main:a.txt") == "pinned"
+    assert len(commands) == 2
+    for command in commands:
+        assert f"UserKnownHostsFile={pinned.resolve()}" in command
+        assert "GlobalKnownHostsFile=/dev/null" in command
+        assert "StrictHostKeyChecking=yes" in command
+    ws.cleanup()
+
+
+def test_state_without_known_hosts_still_restores(tmp_path: Path) -> None:
+    bare = remote(tmp_path)
+    ws = stage_repository(str(bare), root=tmp_path / "jobs", job_id="old-state")
+    state = ws.to_state()
+    del state["known_hosts"]  # a 0.4.1 snapshot
+    restored = GitRepositoryWorkspace.from_state(state)
+    assert restored.known_hosts is None and restored.ssh_key is None
+    restored.discard()
+
+
+@pytest.mark.parametrize("name", ["missing", "with space"])
+def test_bad_known_hosts_rejected_before_cloning(tmp_path: Path, name: str) -> None:
+    key = tmp_path / "id_ed25519"
+    key.write_text("fake private key")
+    pinned = tmp_path / name / "known_hosts"
+    if name != "missing":
+        pinned.parent.mkdir()
+        pinned.write_text("")
+    with pytest.raises(StagingError, match="known_hosts"):
+        stage_repository(
+            "git@host:repo.git",
+            root=tmp_path / "jobs",
+            job_id="ssh-3",
+            ssh_key=key,
+            known_hosts=pinned,
+        )
+    assert not (tmp_path / "jobs" / "ssh-3").exists()
+
+
 def test_missing_ssh_key_rejected(tmp_path: Path) -> None:
     with pytest.raises(StagingError, match="SSH key"):
         stage_repository(