claude-dev-env 8.43.4 → 8.43.6

package/scripts/claude_account_worker.py

@@ -1,54 +1,24 @@
-"""Run a headless Claude worker on the account chosen by the usage picker."""
+"""Run a headless Claude worker through the account broker."""
 
 from __future__ import annotations
 
 import argparse
-import importlib
-import json
-import os
-import shutil
-import subprocess
 import sys
-import time
-from collections.abc import Callable, Mapping
-from dataclasses import dataclass
-from datetime import datetime
 from pathlib import Path
 
-from claude_account_choice import (
-    choose_account_from_extras,
-    config_directory_for_decision,
-    decision_payload,
-    read_account_meters,
-    read_extra_accounts,
-)
-from claude_account_profile import default_profile_home
-from claude_account_worker_process import WorkerProcess, invoke_worker
-from claude_account_worker_report import (
-    WorkerReport,
-    finalize_report,
-    make_report,
-    pre_launch_failure_report,
-    wait_report,
-)
+from account_broker import run_job
+from claude_account_worker_process import invoke_worker
+from claude_account_worker_report import finalize_report, make_report, pre_launch_failure_report, wait_report
+from dev_env_scripts_constants.account_broker_constants import BrokerConfigurationError, JobOutcome
 from dev_env_scripts_constants.claude_account_worker_constants import (
-    CHOICE_MAIN,
-    CHOICE_WAIT,
     CLAUDE_BINARY_NAME,
-    CLAUDE_CONFIG_DIR_ENV_VAR,
     CLI_DESCRIPTION,
-    CREDENTIALS_FILE_NAME,
+    CONFIGURATION_FAILURE_EXIT_CODE,
     CWD_FLAG,
     DEFAULT_PERMISSION_MODE,
     DEFAULT_TIMEOUT_MINUTES,
-    EXTRA_PROFILES_FILE_NAME,
     INVALID_TIMEOUT_MESSAGE,
-    JSON_ACCOUNT_KEY,
-    JSON_CONFIG_DIRECTORY_KEY,
-    JSON_REASON_KEY,
     LAUNCH_FAILURE_EXIT_CODE,
-    MAIN_CLAUDE_HOME_DIRECTORY_NAME,
-    MISSING_BINARY_EXIT_CODE,
     MINIMUM_TIMEOUT_MINUTES,
     MODEL_FLAG,
     OUTPUT_FORMAT_FLAG,
@@ -60,106 +30,8 @@ from dev_env_scripts_constants.claude_account_worker_constants import (
     TIMEOUT_MINUTES_FLAG,
     UTF8_ENCODING,
 )
-from shared_tree_paths import resolve_shared_process_tree_scripts_directory
-
-_process_tree_scripts_directory = resolve_shared_process_tree_scripts_directory(
-    __file__, all_environment=os.environ
-)
-if str(_process_tree_scripts_directory) not in sys.path:
-    sys.path.insert(0, str(_process_tree_scripts_directory))
-
-_process_tree_kill = importlib.import_module("process_tree_kill")
-_terminate_process_tree = _process_tree_kill.terminate_process_tree
-
-
-@dataclass(frozen=True)
-class AccountSelection:
-    account: str
-    config_dir: Path | None
-    reason: str
-
-
-@dataclass(frozen=True)
-class WorkerDependencies:
-    process_factory: Callable[..., WorkerProcess]
-    all_parent_environment_variables: Mapping[str, str]
-    binary_resolver: Callable[[str], str | None]
-    process_terminator: Callable[[WorkerProcess], None]
-    monotonic_clock: Callable[[], float]
-
-
-def _default_dependencies() -> WorkerDependencies:
-    return WorkerDependencies(
-        process_factory=subprocess.Popen,
-        all_parent_environment_variables=os.environ,
-        binary_resolver=shutil.which,
-        process_terminator=_terminate_process_tree,
-        monotonic_clock=time.monotonic,
-    )
-
-
-def _selection_from_payload(all_selection_payload: Mapping[str, str | None]) -> AccountSelection:
-    account = all_selection_payload[JSON_ACCOUNT_KEY]
-    reason = all_selection_payload[JSON_REASON_KEY]
-    config_dir_text = all_selection_payload[JSON_CONFIG_DIRECTORY_KEY]
-    if account is None or reason is None:
-        raise ValueError("account picker returned an incomplete decision")
-    return AccountSelection(
-        account=account,
-        config_dir=Path(config_dir_text) if config_dir_text is not None else None,
-        reason=reason,
-    )
-
-
-def extra_config_directories(main_config_dir: Path) -> tuple[Path, ...]:
-    """Read the ordered local profile list or use the legacy default.
-
-    Args:
-        main_config_dir: The main Claude home that may hold the list file.
-
-    Returns:
-        The extra profile homes in the order they are tried.
 
-    Raises:
-        ValueError: When the list is empty, holds a non-name, or repeats a name.
-    """
-    profiles_file = main_config_dir / EXTRA_PROFILES_FILE_NAME
-    if not profiles_file.exists():
-        return (default_profile_home(),)
-    profile_names = json.loads(profiles_file.read_text(encoding=UTF8_ENCODING))
-    if (
-        not isinstance(profile_names, list)
-        or not profile_names
-        or any(not isinstance(name, str) for name in profile_names)
-    ):
-        raise ValueError("extra profile list must be a nonempty JSON list of names")
-    if len({name.casefold() for name in profile_names}) != len(profile_names):
-        raise ValueError("extra profile names must be distinct")
-    return tuple(default_profile_home(name) for name in profile_names)
-
-
-def select_account() -> AccountSelection:
-    """Pick the account this worker runs on and its Claude home directory.
-
-    Returns:
-        The chosen account, its Claude config directory, and the reason.
-
-    Raises:
-        ValueError: When the profile list or account decision is invalid.
-    """
-    main_config_dir = Path.home() / MAIN_CLAUDE_HOME_DIRECTORY_NAME
-    extra_accounts = read_extra_accounts(extra_config_directories(main_config_dir))
-    main_meters = read_account_meters(main_config_dir / CREDENTIALS_FILE_NAME)
-    decision = choose_account_from_extras(
-        main_meters=main_meters,
-        all_extra_accounts=extra_accounts,
-        now=datetime.now().astimezone(),
-    )
-    selected_config_dir = config_directory_for_decision(
-        decision, main_config_dir=main_config_dir, all_extra_accounts=extra_accounts
-    )
-    payload = decision_payload(decision, config_directory=selected_config_dir)
-    return _selection_from_payload(payload)
+worker_job_runner = run_job
 
 
 def _positive_timeout_minutes(candidate_text: str) -> int:
@@ -170,52 +42,20 @@ def _positive_timeout_minutes(candidate_text: str) -> int:
 
 
 def build_argument_parser() -> argparse.ArgumentParser:
-    """Build the CLI parser for one headless worker invocation.
-
-    Returns:
-        The configured argument parser.
-    """
+    """Build the CLI parser for one headless worker invocation."""
     parser = argparse.ArgumentParser(description=CLI_DESCRIPTION)
     parser.add_argument(PROMPT_FILE_FLAG, type=Path, required=True)
     parser.add_argument(CWD_FLAG, type=Path, default=Path.cwd())
     parser.add_argument(REPORT_FILE_FLAG, type=Path, required=True)
     parser.add_argument(MODEL_FLAG)
-    parser.add_argument(
-        PERMISSION_MODE_FLAG,
-        default=DEFAULT_PERMISSION_MODE,
-    )
-    parser.add_argument(
-        TIMEOUT_MINUTES_FLAG,
-        type=_positive_timeout_minutes,
-        default=DEFAULT_TIMEOUT_MINUTES,
-    )
+    parser.add_argument(PERMISSION_MODE_FLAG, default=DEFAULT_PERMISSION_MODE)
+    parser.add_argument(TIMEOUT_MINUTES_FLAG, type=_positive_timeout_minutes, default=DEFAULT_TIMEOUT_MINUTES)
     return parser
 
 
-def _child_environment(
-    selection: AccountSelection,
-    all_environment_variables: Mapping[str, str],
-) -> dict[str, str]:
-    all_child_environment_variables = dict(all_environment_variables)
-    if selection.account == CHOICE_MAIN:
-        all_child_environment_variables.pop(CLAUDE_CONFIG_DIR_ENV_VAR, None)
-        return all_child_environment_variables
-    if selection.account == CHOICE_WAIT:
-        raise ValueError("wait selection cannot launch a worker")
-    if selection.config_dir is None:
-        raise ValueError("extra account selection needs a config directory")
-    all_child_environment_variables[CLAUDE_CONFIG_DIR_ENV_VAR] = str(selection.config_dir)
-    return all_child_environment_variables
-
-
-def _invocation(
-    executable: str,
-    *,
-    model: str | None,
-    permission_mode: str,
-) -> list[str]:
-    all_arguments = [
-        executable,
+def _invocation(*, model: str | None, permission_mode: str) -> list[str]:
+    arguments = [
+        CLAUDE_BINARY_NAME,
         SINGLE_PROMPT_FLAG,
         OUTPUT_FORMAT_FLAG,
         OUTPUT_FORMAT_JSON,
@@ -223,106 +63,14 @@ def _invocation(
         permission_mode,
     ]
     if model is not None:
-        all_arguments.extend([MODEL_FLAG, model])
-    return all_arguments
+        arguments.extend([MODEL_FLAG, model])
+    return arguments
 
 
-def _prepared_launch(
-    selection: AccountSelection,
-    prompt_file: Path,
-    dependencies: WorkerDependencies,
-) -> tuple[dict[str, str], str, str] | WorkerReport:
-    try:
-        all_child_environment_variables = _child_environment(
-            selection, dependencies.all_parent_environment_variables
-        )
-        prompt_text = prompt_file.read_text(encoding=UTF8_ENCODING)
-    except (OSError, ValueError):
-        return pre_launch_failure_report(
-            selection.account, selection.reason, LAUNCH_FAILURE_EXIT_CODE
-        )
-    claude_binary = dependencies.binary_resolver(CLAUDE_BINARY_NAME)
-    if claude_binary is None:
-        return pre_launch_failure_report(
-            selection.account, selection.reason, MISSING_BINARY_EXIT_CODE
-        )
-    return all_child_environment_variables, prompt_text, claude_binary
-
-
-def _invoked_report(
-    selection: AccountSelection,
-    *,
-    all_arguments: list[str],
-    cwd: Path,
-    all_child_environment_variables: dict[str, str],
-    prompt_text: str,
-    timeout_minutes: int,
-    dependencies: WorkerDependencies,
-) -> WorkerReport:
-    exit_code, duration_seconds, stdout_text = invoke_worker(
-        all_arguments=all_arguments,
-        cwd=cwd,
-        all_child_environment_variables=all_child_environment_variables,
-        prompt_text=prompt_text,
-        timeout_minutes=timeout_minutes,
-        controls=dependencies,
-    )
-    return make_report(
-        selection.account,
-        selection.reason,
-        exit_code=exit_code,
-        duration_seconds=duration_seconds,
-        stdout_text=stdout_text,
-    )
-
-
-def _worker_report(
-    selection: AccountSelection,
-    *,
-    prompt_file: Path,
-    cwd: Path,
-    model: str | None,
-    permission_mode: str,
-    timeout_minutes: int,
-    dependencies: WorkerDependencies,
-) -> WorkerReport:
-    prepared = _prepared_launch(selection, prompt_file, dependencies)
-    if isinstance(prepared, WorkerReport):
-        return prepared
-    all_child_environment_variables, prompt_text, claude_binary = prepared
-    all_arguments = _invocation(claude_binary, model=model, permission_mode=permission_mode)
-    return _invoked_report(
-        selection,
-        all_arguments=all_arguments,
-        cwd=cwd,
-        all_child_environment_variables=all_child_environment_variables,
-        prompt_text=prompt_text,
-        timeout_minutes=timeout_minutes,
-        dependencies=dependencies,
-    )
-
-
-def _report_for_selection(
-    selection: AccountSelection,
-    *,
-    prompt_file: Path,
-    cwd: Path,
-    model: str | None,
-    permission_mode: str,
-    timeout_minutes: int,
-    dependencies: WorkerDependencies,
-) -> WorkerReport:
-    if selection.account == CHOICE_WAIT:
-        return wait_report(selection.account, selection.reason)
-    return _worker_report(
-        selection,
-        prompt_file=prompt_file,
-        cwd=cwd,
-        model=model,
-        permission_mode=permission_mode,
-        timeout_minutes=timeout_minutes,
-        dependencies=dependencies,
-    )
+def _wait_reason(outcome: JobOutcome) -> str:
+    if outcome.wait_reset_at is None:
+        return "no account has room"
+    return f"no account has room; next reset at {outcome.wait_reset_at.isoformat()}"
 
 
 def run_worker(
@@ -333,36 +81,39 @@ def run_worker(
     model: str | None,
     permission_mode: str,
     timeout_minutes: int,
-    decision_selector: Callable[[], AccountSelection],
-    dependencies: WorkerDependencies,
 ) -> int:
-    """Pick an account and run one headless Claude worker on it.
-
-    Args:
-        prompt_file, report_file: The prompt and report file paths.
-        decision_selector, dependencies: The picker and process controls.
-    Returns:
-        The exit code: 3 on wait, 124 on timeout, 127 on a missing binary,
-        or the child's own exit code.
-    """
-    report = _report_for_selection(
-        decision_selector(),
-        prompt_file=prompt_file,
-        cwd=cwd,
-        model=model,
-        permission_mode=permission_mode,
-        timeout_minutes=timeout_minutes,
-        dependencies=dependencies,
+    """Run one worker and write its structured report."""
+    try:
+        prompt_text = prompt_file.read_text(encoding=UTF8_ENCODING)
+    except (OSError, UnicodeError):
+        report = pre_launch_failure_report("none", "prompt file is unreadable", LAUNCH_FAILURE_EXIT_CODE)
+        return finalize_report(report_file, report)
+    try:
+        outcome, duration_seconds = invoke_worker(
+            all_arguments=_invocation(model=model, permission_mode=permission_mode),
+            cwd=cwd,
+            prompt_text=prompt_text,
+            timeout_minutes=timeout_minutes,
+            runner=worker_job_runner,
+        )
+    except BrokerConfigurationError as error:
+        report = pre_launch_failure_report("none", str(error), CONFIGURATION_FAILURE_EXIT_CODE)
+        return finalize_report(report_file, report)
+    if outcome.status in {"wait", "exhausted"}:
+        report = wait_report("wait", _wait_reason(outcome), outcome.wait_reset_at)
+        return finalize_report(report_file, report)
+    report = make_report(
+        outcome.account_name or "none",
+        outcome.status,
+        exit_code=outcome.returncode,
+        duration_seconds=duration_seconds,
+        stdout_text=outcome.stdout,
     )
     return finalize_report(report_file, report)
 
 
 def main() -> int:
-    """Parse CLI arguments and run one headless worker.
-
-    Returns:
-        The worker's exit code.
-    """
+    """Parse CLI arguments and run one headless worker."""
     arguments = build_argument_parser().parse_args()
     return run_worker(
         prompt_file=arguments.prompt_file,
@@ -371,8 +122,6 @@ def main() -> int:
         model=arguments.model,
         permission_mode=arguments.permission_mode,
         timeout_minutes=arguments.timeout_minutes,
-        decision_selector=select_account,
-        dependencies=_default_dependencies(),
     )
 
 

package/scripts/claude_account_worker_process.py

@@ -1,169 +1,33 @@
-"""Launch a headless Claude worker process and wait for it to finish."""
+"""Run a headless Claude worker through the account broker."""
 
 from __future__ import annotations
 
-import importlib
-import os
-import subprocess
-import sys
+import time
 from collections.abc import Callable
 from pathlib import Path
-from typing import Protocol
 
-from dev_env_scripts_constants.claude_account_worker_constants import (
-    DRAIN_ATTEMPT_LIMIT,
-    DRAIN_GRACE_TIMEOUT_SECONDS,
-    LAUNCH_FAILURE_EXIT_CODE,
-    SECONDS_PER_MINUTE,
-    TIMEOUT_EXIT_CODE,
-    UTF8_DECODE_ERRORS,
-    UTF8_ENCODING,
-)
-from shared_tree_paths import resolve_shared_process_tree_scripts_directory
-from subprocess_stream_text import decode_stream_text
-from subprocess_window_access import hidden_window_creation_flags
-
-_process_tree_scripts_directory = resolve_shared_process_tree_scripts_directory(
-    __file__, all_environment=os.environ
-)
-if str(_process_tree_scripts_directory) not in sys.path:
-    sys.path.insert(0, str(_process_tree_scripts_directory))
-
-_process_tree_kill = importlib.import_module("process_tree_kill")
-_should_start_new_session = _process_tree_kill.should_start_new_session
-
-
-class WorkerProcess(Protocol):
-    returncode: int | None
-
-    pid: int
-
-    def communicate(
-        self,
-        input: str | None = None,
-        timeout: float | None = None,
-    ) -> tuple[str | bytes | None, str | bytes | None]: ...
-
-    def poll(self) -> int | None: ...
-
-    def kill(self) -> None: ...
-
-
-def _decoded_text(stream_payload: str | bytes | None) -> str:
-    return decode_stream_text(
-        stream_payload, encoding=UTF8_ENCODING, errors=UTF8_DECODE_ERRORS
-    )
-
-
-def _launch_process(
-    process_factory: Callable[..., WorkerProcess],
-    all_arguments: list[str],
-    cwd: Path,
-    all_child_environment_variables: dict[str, str],
-) -> WorkerProcess | None:
-    try:
-        return process_factory(
-            all_arguments,
-            cwd=str(cwd),
-            env=all_child_environment_variables,
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            encoding=UTF8_ENCODING,
-            errors=UTF8_DECODE_ERRORS,
-            start_new_session=_should_start_new_session(),
-            creationflags=hidden_window_creation_flags(),
-        )
-    except OSError:
-        return None
-
-
-def _drain_attempt_outcome(process: WorkerProcess) -> tuple[bool, str]:
-    try:
-        captured_stdout, _ = process.communicate(timeout=DRAIN_GRACE_TIMEOUT_SECONDS)
-    except subprocess.TimeoutExpired as timeout_error:
-        return False, _decoded_text(timeout_error.output)
-    return True, _decoded_text(captured_stdout)
-
-
-def _drain_after_termination(
-    process: WorkerProcess,
-    process_terminator: Callable[[WorkerProcess], None],
-    initial_stdout_text: str,
-) -> str:
-    latest_stdout_text = initial_stdout_text
-    for _ in range(DRAIN_ATTEMPT_LIMIT):
-        process_terminator(process)
-        did_drain, attempt_stdout_text = _drain_attempt_outcome(process)
-        if attempt_stdout_text:
-            latest_stdout_text = attempt_stdout_text
-        if did_drain:
-            return latest_stdout_text
-    return latest_stdout_text
-
-
-class ProcessControls(Protocol):
-    """The process factory, terminator, and clock a worker run uses."""
-
-    process_factory: Callable[..., WorkerProcess]
-    process_terminator: Callable[[WorkerProcess], None]
-    monotonic_clock: Callable[[], float]
-
-
-def _await_completion(
-    process: WorkerProcess | None,
-    prompt_text: str,
-    timeout_minutes: int,
-    process_terminator: Callable[[WorkerProcess], None],
-) -> tuple[int, str]:
-    if process is None:
-        return LAUNCH_FAILURE_EXIT_CODE, ""
-    try:
-        captured_stdout, _ = process.communicate(
-            input=prompt_text,
-            timeout=timeout_minutes * SECONDS_PER_MINUTE,
-        )
-    except subprocess.TimeoutExpired as timeout_error:
-        stdout_text = _drain_after_termination(
-            process, process_terminator, _decoded_text(timeout_error.output)
-        )
-        return TIMEOUT_EXIT_CODE, stdout_text
-    process_exit_code = (
-        process.returncode
-        if process.returncode is not None
-        else LAUNCH_FAILURE_EXIT_CODE
-    )
-    return process_exit_code, _decoded_text(captured_stdout)
+from dev_env_scripts_constants.account_broker_constants import JobOutcome, Product
+from dev_env_scripts_constants.claude_account_worker_constants import SECONDS_PER_MINUTE
 
 
 def invoke_worker(
     *,
     all_arguments: list[str],
     cwd: Path,
-    all_child_environment_variables: dict[str, str],
     prompt_text: str,
     timeout_minutes: int,
-    controls: ProcessControls,
-) -> tuple[int, float, str]:
-    """Launch the worker process and return its exit code, duration, and stdout.
-
-    Args:
-        all_arguments: The full command line, executable first.
-        cwd: Working directory the child process runs in.
-        all_child_environment_variables: Environment passed to the child.
-        prompt_text: The prompt piped to the child on stdin.
-        timeout_minutes: Minutes to wait before the child is timed out.
-        controls: The process factory, terminator, and clock.
-
-    Returns:
-        The exit code, the duration in seconds, and the decoded stdout.
-    """
-    process_start = controls.monotonic_clock()
-    process = _launch_process(
-        controls.process_factory, all_arguments, cwd, all_child_environment_variables
-    )
-    exit_code, stdout_text = _await_completion(
-        process, prompt_text, timeout_minutes, controls.process_terminator
+    runner: Callable[..., JobOutcome],
+    monotonic_clock: Callable[[], float] = time.monotonic,
+) -> tuple[JobOutcome, float]:
+    """Run one broker job and measure its elapsed time."""
+    started_at = monotonic_clock()
+    outcome = runner(
+        Product.CLAUDE,
+        all_arguments,
+        timeout_seconds=timeout_minutes * SECONDS_PER_MINUTE,
+        stdin_text=prompt_text,
+        cwd=cwd,
+        encoding="utf-8",
+        errors="replace",
     )
-    return exit_code, controls.monotonic_clock() - process_start, stdout_text
+    return outcome, monotonic_clock() - started_at

package/scripts/claude_account_worker_report.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import json
 from dataclasses import dataclass
+from datetime import datetime
 from pathlib import Path
 
 from dev_env_scripts_constants.claude_account_worker_constants import (
@@ -33,6 +34,7 @@ class WorkerReport:
     duration_seconds: float
     payload: object
     is_error: bool
+    wait_reset_at: datetime | None = None
 
 
 def _bounded_stdout_tail(stdout_text: str) -> str:
@@ -49,12 +51,12 @@ def _extract_payload(stdout_text: str) -> tuple[object, bool]:
     return parsed_stdout[JSON_RESULT_KEY], parsed_stdout.get(JSON_IS_ERROR_KEY) is True
 
 
-def wait_report(account: str, reason: str) -> WorkerReport:
+def wait_report(account: str, reason: str, wait_reset_at: datetime | None) -> WorkerReport:
     """Build the report for an account decision that says to wait.
 
     Args:
         account: The chosen account slot.
-        reason: Why the picker chose to wait.
+        reason: Why the broker returned a wait decision.
 
     Returns:
         A report carrying the wait exit code and no payload.
@@ -65,7 +67,8 @@ def wait_report(account: str, reason: str) -> WorkerReport:
         exit_code=WAIT_EXIT_CODE,
         duration_seconds=WAIT_DURATION_SECONDS,
         payload=None,
-        is_error=True,
+        is_error=False,
+        wait_reset_at=wait_reset_at,
     )
 
 
@@ -81,7 +84,7 @@ def make_report(
 
     Args:
         account: The chosen account slot.
-        reason: Why the picker chose that account.
+        reason: Broker status for the account.
         exit_code: The worker process's exit code.
         duration_seconds: How long the worker ran.
         stdout_text: The worker's captured stdout text.
@@ -138,6 +141,7 @@ def write_report(report_file: Path, report: WorkerReport) -> None:
         REPORT_DURATION_SECONDS_KEY: report.duration_seconds,
         REPORT_RESULT_KEY: report.payload,
         REPORT_IS_ERROR_KEY: report.is_error,
+        "wait_reset_at": report.wait_reset_at.isoformat() if report.wait_reset_at else None,
     }
     report_file.write_text(
         json.dumps(report_payload, ensure_ascii=False, indent=REPORT_INDENT) + "\n",