@matt82198/aesop 0.3.2 → 0.4.0

package/driver/claude_code_driver.py

@@ -35,7 +35,6 @@ Claude agent from plain Python.
 stdlib-only, ASCII-only, Windows + Linux safe.
 """
 
-import subprocess
 from typing import Optional
 
 from agent_driver import (
@@ -50,6 +49,7 @@ from agent_driver import (
     WorkerStatus,
     WORKER_UNKNOWN,
 )
+from proc_util import run_shell_bounded
 
 
 # Default abstract-role -> Anthropic model mapping. Workers are Haiku by policy
@@ -75,11 +75,12 @@ class ClaudeCodeDriver(AgentDriver):
 
     name = "claude-code"
 
-    def __init__(self, model_map: Optional[dict] = None):
+    def __init__(self, model_map: Optional[dict] = None, timeout_s: float = 120.0):
         # Copy so callers cannot mutate our defaults; fall back per-role.
         self._model_map = dict(_DEFAULT_MODEL_MAP)
         if model_map:
             self._model_map.update(model_map)
+        self._timeout_s = timeout_s
 
     # -- Operation 1: capability probe (concrete) --------------------------
     def probe_capabilities(self) -> DriverCapabilities:
@@ -149,22 +150,13 @@ class ClaudeCodeDriver(AgentDriver):
         real subprocess so tooling/tests get genuine behavior. `shell` is
         advisory -- we always execute through the platform shell so the same
         call works on Windows and Linux.
+
+        Timeouts truly bound wall-clock (RS-A F1): on expiry the WHOLE process
+        tree is killed (taskkill /T on Windows, killpg on POSIX) and we return
+        exit 124 promptly, preserving any partial output captured before the
+        kill (RS-A F7). See proc_util.run_shell_bounded.
         """
-        try:
-            completed = subprocess.run(
-                command,
-                cwd=cwd,
-                shell=True,
-                capture_output=True,
-                text=True,
-            )
-            return CommandResult(
-                exit_code=completed.returncode,
-                stdout=completed.stdout or "",
-                stderr=completed.stderr or "",
-            )
-        except OSError as exc:
-            return CommandResult(exit_code=127, stdout="", stderr=str(exc))
+        return run_shell_bounded(command, cwd=cwd, timeout_s=self._timeout_s)
 
     # -- Operation 5: model selection (concrete) ---------------------------
     def resolve_model(self, role: str) -> str:

package/driver/codex_driver.py

@@ -34,11 +34,12 @@ stdlib-only, ASCII-only, Windows + Linux safe.
 import hashlib
 import json
 import os
-import subprocess
 import time
 from pathlib import Path
 from typing import Dict, Optional
 
+from proc_util import run_shell_bounded
+
 from agent_driver import (
     AgentDriver,
     CommandResult,
@@ -176,6 +177,7 @@ class CodexDriver(AgentDriver):
         max_retries: int = 2,
         timeout_s: float = 120.0,
         allow_unverified_models: bool = False,
+        command_timeout_s: Optional[float] = None,
     ):
         """Initialize the CodexDriver with optional overrides.
 
@@ -185,9 +187,12 @@ class CodexDriver(AgentDriver):
             now: callable returning time.time() for testing (default=time.time).
             max_owned_bytes: max total bytes of owned files before pre-dispatch fail (default 200KB).
             max_retries: max in-turn retries on malformed JSON (default 2).
-            timeout_s: HTTP timeout in seconds (default 120).
+            timeout_s: HTTP transport timeout + worker_status stall threshold, seconds (default 120).
             allow_unverified_models: if True, allow models not known to support json_schema
                 (default False). Set to True only for experimental backends.
+            command_timeout_s: run_command wall-clock bound, seconds. Defaults to
+                timeout_s when unset, but is separately settable so raising the
+                HTTP timeout never silently raises the command timeout (RS-A F7).
 
         Raises:
             ValueError: if any mapped model is not in JSON_SCHEMA_CAPABLE and
@@ -207,11 +212,28 @@ class CodexDriver(AgentDriver):
                         f"Pass allow_unverified_models=True to override (for experimental backends)."
                     )
 
-        self._transport = transport or default_openai_transport
         self._now = now or time.time
         self._max_owned_bytes = max_owned_bytes
         self._max_retries = max_retries
         self._timeout_s = timeout_s
+        # run_command gets its OWN knob (falls back to timeout_s) so the HTTP
+        # timeout and the command wall-clock bound are independently tunable.
+        self._command_timeout_s = (
+            command_timeout_s if command_timeout_s is not None else timeout_s
+        )
+
+        # Transport wiring. When falling back to the default transport, BIND the
+        # configured timeout: default_openai_transport has its own timeout_s=120
+        # default, so without this wrapper a configured timeout_s was silently
+        # ignored for the HTTP call (it only fed worker_status stall math).
+        if transport is not None:
+            self._transport = transport
+        elif default_openai_transport is not None:
+            self._transport = lambda payload: default_openai_transport(
+                payload, timeout_s=self._timeout_s
+            )
+        else:
+            self._transport = None
 
         # In-memory registry of worker status (worker_id -> {start_time, last_output_time, result}).
         self._worker_registry: Dict[str, dict] = {}
@@ -419,12 +441,21 @@ class CodexDriver(AgentDriver):
             structured = None
             last_error = None
             last_content = ""
+            last_failure_was_transport = False
 
             for attempt in range(self._max_retries + 1):
+                # Transport call. Network/auth/HTTP failures are NOT JSON
+                # validation errors: the model never produced output, so a
+                # schema nudge is meaningless. Retry (covers transients) but
+                # without appending nudge messages, and label honestly.
                 try:
-                    # Call transport.
                     response = self._transport(payload)
+                except Exception as exc:
+                    last_error = f"transport error: {exc}"
+                    last_failure_was_transport = True
+                    continue
 
+                try:
                     # Extract and parse JSON.
                     if "choices" not in response or not response["choices"]:
                         raise ValueError("no choices in response")
@@ -437,8 +468,9 @@ class CodexDriver(AgentDriver):
                     # Success: break out of retry loop.
                     break
 
-                except (json.JSONDecodeError, ValueError, KeyError, Exception) as exc:
+                except (json.JSONDecodeError, ValueError, KeyError) as exc:
                     last_error = str(exc)
+                    last_failure_was_transport = False
                     # If we have retries left, append error feedback and retry.
                     if attempt < self._max_retries:
                         # Before appending retry messages, check if total payload would exceed budget.
@@ -479,21 +511,41 @@ class CodexDriver(AgentDriver):
                         )
                     continue
 
-            # If validation still failed after all retries.
+            # If transport or validation still failed after all retries.
             if structured is None:
+                if last_failure_was_transport:
+                    error_msg = (
+                        f"transport failed after {self._max_retries + 1} "
+                        f"attempts: {last_error}"
+                    )
+                else:
+                    error_msg = (
+                        f"structured output validation failed after "
+                        f"{self._max_retries + 1} attempts: {last_error}"
+                    )
                 return WorkerResult(
                     worker_id=worker_id,
                     status=WORKER_FAILED,
                     ok=False,
-                    error=f"structured output validation failed after {self._max_retries + 1} attempts: {last_error}",
+                    error=error_msg,
                     text=last_content,
                 )
 
             # 8. Ownership enforcement: all returned paths must be in owned_files.
+            # Match under the SAME cross-platform policy as the read side
+            # (backslashes are separators on every OS): a Windows-authored
+            # manifest owning "src\\util.py" must accept a model returning
+            # "src/util.py" instead of failing spuriously as out-of-scope.
+            # SECURITY: the write always uses the canonical owned entry (which
+            # passed containment above), never the model's raw string.
+            owned_lookup = {
+                p.replace("\\", "/"): p for p in request.owned_files
+            }
             files_to_write = []
             for file_entry in structured.get("files", []):
                 path_str = file_entry.get("path", "")
-                if path_str not in request.owned_files:
+                canonical = owned_lookup.get(path_str.replace("\\", "/"))
+                if canonical is None:
                     # Distinguish: path not in the owned set (security/isolation violation).
                     return WorkerResult(
                         worker_id=worker_id,
@@ -501,21 +553,30 @@ class CodexDriver(AgentDriver):
                         ok=False,
                         error=f"out-of-scope: worker attempted to write {path_str} (not in owned set)",
                     )
-                files_to_write.append((path_str, file_entry["contents"]))
+                files_to_write.append((canonical, file_entry["contents"]))
 
             # 9. Apply (validate ALL before writing ANY).
             written_paths = []
             for path_str, new_contents in files_to_write:
-                full_path = Path(request.workdir) / path_str
+                # Normalize separators for the write target: on POSIX a backslash
+                # is a literal filename char, so an owned path declared "src\c.py"
+                # must become "src/c.py" before Path() (mirrors the read path above).
+                # written_paths keeps the canonical path_str for record-keeping.
+                full_path = Path(request.workdir) / path_str.replace("\\", "/")
                 try:
                     full_path.write_text(new_contents, encoding="utf-8")
                     written_paths.append(path_str)
                 except OSError as exc:
                     # Distinguish: owned path exists but write failed (OS error).
+                    # HONESTY: report the files ALREADY written before the
+                    # failure -- a mid-loop failure leaves the tree partially
+                    # modified with no rollback, and the orchestrator must know
+                    # which files are dirty rather than believing none changed.
                     return WorkerResult(
                         worker_id=worker_id,
                         status=WORKER_FAILED,
                         ok=False,
+                        files_written=tuple(written_paths),
                         error=f"write_failed: {path_str}: {exc}",
                     )
 
@@ -624,22 +685,16 @@ class CodexDriver(AgentDriver):
 
         Real subprocess execution (not a worker tool). Used for tests, git,
         verification. Mirrors ClaudeCodeDriver.run_command for parity.
+
+        Timeouts truly bound wall-clock (RS-A F1): on expiry the WHOLE process
+        tree is killed (taskkill /T on Windows, killpg on POSIX) and we return
+        exit 124 promptly, preserving any partial output captured before the
+        kill (RS-A F7). Bounded by command_timeout_s (NOT the HTTP timeout).
+        See proc_util.run_shell_bounded.
         """
-        try:
-            completed = subprocess.run(
-                command,
-                cwd=cwd,
-                shell=True,
-                capture_output=True,
-                text=True,
-            )
-            return CommandResult(
-                exit_code=completed.returncode,
-                stdout=completed.stdout or "",
-                stderr=completed.stderr or "",
-            )
-        except OSError as exc:
-            return CommandResult(exit_code=127, stdout="", stderr=str(exc))
+        return run_shell_bounded(
+            command, cwd=cwd, timeout_s=self._command_timeout_s
+        )
 
     # -- Operation 5: model selection (concrete) -------------------------
     def resolve_model(self, role: str) -> str: