okstra 0.163.2 → 0.165.0

package/runtime/python/okstra_ctl/worker_request.py

@@ -0,0 +1,140 @@
+"""Assemble the request every provider strategy then takes on trust.
+
+A strategy translates a ``WorkerExecRequest`` into its CLI's syntax and nothing
+more: it does not resolve paths, does not decide what may be written, and does
+not know which role it is running. Whoever builds the request answers all
+three, so the answers live here — importable — rather than inside a dispatch
+entrypoint where the next caller would have to copy them.
+"""
+from __future__ import annotations
+
+import os
+import subprocess
+from pathlib import Path
+
+from .domain.worker_exec import ExecutionPolicy, WorkerExecRequest
+from .domain.worker_role import role_spec
+
+# Carried over from the codex wrapper, where it was one provider's rule: cargo's
+# package-cache flock and its registry live outside every workspace, so a
+# verifier bounded to the tree alone fails each `cargo build/test/clippy` on the
+# global lock. The rule follows the role rather than the provider now — every
+# provider's verifier receives these — so the name no longer says codex. Set it
+# to a colon-separated list of absolute paths to override, or to empty to
+# disable.
+VERIFIER_EXTRA_DIRS_ENV = "OKSTRA_VERIFIER_EXTRA_DIRS"
+
+_VERIFIER_ROLE = "verifier"
+
+
+def build_request(
+    *,
+    prompt_text: str,
+    model: str,
+    project_root: Path,
+    worktree_path: Path | None,
+    role: str,
+    idle_timeout_seconds: int,
+) -> WorkerExecRequest:
+    """One dispatch, with every value the strategies will not re-derive.
+
+    Paths are resolved here because nothing downstream resolves them: the
+    strategies hand what they are given straight to a CLI, so an unresolved
+    `..` or symlink would survive into the sandbox boundary itself.
+    """
+    root = project_root.resolve()
+    worktree = worktree_path.resolve() if worktree_path is not None else None
+    return WorkerExecRequest(
+        prompt_text=prompt_text,
+        model=model,
+        project_root=root,
+        worktree_path=worktree,
+        # Nobody is at the keyboard to answer an approval prompt, so the gate is
+        # open and the boundary comes from the write scope instead.
+        policy=ExecutionPolicy(
+            auto_approve=True, write_scope=write_scope(root, worktree, role)
+        ),
+        idle_timeout_seconds=idle_timeout_seconds,
+    )
+
+
+def write_scope(
+    project_root: Path, worktree: Path | None, role: str
+) -> tuple[Path, ...]:
+    """What this worker may write, in the order the CLIs are told it.
+
+    The order is contract, not taste: strategies translate this tuple into
+    repeated `--add-dir` positionally, so it mirrors what the shell wrappers
+    claimed. The project root leads (the antigravity wrapper's first
+    `--add-dir`; codex names it with `-C` and its strategy skips the repeat),
+    then the stage tree, then the git directory that tree commits through.
+
+    The worktree belongs here as well as in the request: passing it as the
+    working directory alone produces an argv with no `--add-dir`, and the worker
+    then fails by not writing files rather than by erroring.
+    """
+    scope = [project_root]
+    if worktree is not None:
+        scope.append(worktree)
+        common_git_dir = git_common_dir(worktree)
+        if common_git_dir is not None:
+            scope.append(common_git_dir)
+    scope.extend(verifier_extra_dirs(role))
+    return tuple(scope)
+
+
+def git_common_dir(worktree: Path) -> Path | None:
+    """The main repository's `.git`, which a linked worktree commits through.
+
+    A linked worktree keeps its index and refs under the main repo's `.git` and
+    shares its object database, so a worker bounded to the tree alone cannot
+    `git commit` from it. A directory that is no worktree at all simply has
+    nothing extra to grant.
+    """
+    try:
+        probe = subprocess.run(
+            ["git", "-C", str(worktree), "rev-parse", "--git-common-dir"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+    except OSError:
+        return None
+    if probe.returncode != 0 or not probe.stdout.strip():
+        return None
+    candidate = Path(probe.stdout.strip())
+    if not candidate.is_absolute():
+        candidate = worktree / candidate
+    return candidate.resolve() if candidate.is_dir() else None
+
+
+def verifier_extra_dirs(role: str) -> tuple[Path, ...]:
+    """Toolchain directories granted to the verifier role only.
+
+    Role decides this, not the provider, so it is assembled here rather than in
+    a strategy — and not in `WorkerRoleSpec`, which holds values that hold for
+    every machine while these paths exist only where the toolchain is.
+    """
+    if role != _VERIFIER_ROLE:
+        return ()
+    home = Path.home()
+    raw = os.environ.get(VERIFIER_EXTRA_DIRS_ENV, f"{home}/.cargo:{home}/.rustup")
+    candidates = (Path(entry) for entry in raw.split(":") if entry)
+    return tuple(path.resolve() for path in candidates if path.is_dir())
+
+
+def idle_timeout(raw: str, role: str) -> int:
+    """The explicit budget, or the one the role's spec owns.
+
+    The default is not written here. The same 1500/600 pair used to live in
+    every wrapper and in the python entrypoint, and each copy could drift from
+    the policy. Raises ``ValueError`` on a malformed budget; the exit code that
+    failure earns belongs to the entrypoint, not to this module.
+    """
+    if not raw:
+        return role_spec(role).idle_timeout_seconds
+    if not raw.isdigit():
+        raise ValueError(
+            f"idle-timeout-seconds must be a non-negative integer: {raw!r}"
+        )
+    return int(raw)