claude-dev-env 8.43.5 → 8.43.6

package/scripts/claude_chain_usage.py

@@ -1,42 +1,17 @@
-#!/usr/bin/env python3
-"""Report remaining weekly usage for every account in the Claude chain.
-
-Loads ``~/.claude/claude-chain.json`` (or a path the caller names), probes each
-entry's weekly utilization through the usage-pause OAuth endpoint, and prints a
-JSON report. Ranking is available as an importable helper; ``run_claude``
-consumes that ranking to choose try order.
-
-::
-
-    python claude_chain_usage.py
-    {"accounts": [
-      {"command": "claude", "weekly_remaining_percent": 58.0},
-      {"command": "claude-profile-c", "weekly_remaining_percent": null, "error": "..."}
-    ]}
-"""
+"""Probe Claude account usage meters for the account broker."""
 
 from __future__ import annotations
 
-import argparse
 import http.client
 import importlib.util
-import json
 import sys
 import urllib.error
-from collections.abc import Callable
 from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
 from types import ModuleType
 
-from dev_env_scripts_constants.claude_chain_constants import CHAIN_CONFIG_ERROR_EXIT_CODE
 from dev_env_scripts_constants.claude_chain_usage_constants import (
-    CLI_CONFIG_PATH_FLAG,
-    FULL_WEEKLY_PERCENT,
-    JSON_ACCOUNTS_KEY,
-    JSON_COMMAND_KEY,
-    JSON_ERROR_KEY,
-    JSON_WEEKLY_REMAINING_PERCENT_KEY,
     NO_ACCESS_TOKEN_ERROR_TEMPLATE,
     RESOLVE_USAGE_WINDOW_FILENAME,
     RESOLVE_USAGE_WINDOW_MISSING_ERROR_TEMPLATE,
@@ -46,38 +21,11 @@ from dev_env_scripts_constants.claude_chain_usage_constants import (
     USAGE_PAUSE_SKILL_DIRECTORY_NAME,
     USAGE_PAUSE_SKILL_NAME,
     USAGE_PROBE_FAILED_ERROR_TEMPLATE,
-    WEEKLY_UTILIZATION_MISSING_ERROR,
 )
 
-import claude_chain_runner as chain_runner
-
-WeeklyUtilizationProbe = Callable[[Path], float]
-
 
 class WeeklyUtilizationProbeError(Exception):
-    """Raised when the weekly_utilization_probe cannot measure one account."""
-
-
-@dataclass(frozen=True)
-class AccountUsageReport:
-    """One chain account's remaining weekly usage, or the reason it is unknown."""
-
-    command: str
-    weekly_remaining_percent: float | None
-    error: str | None = None
-
-
-def _default_credentials_path() -> Path:
-    usage_window_resolver = _load_resolve_usage_window_module()
-    return Path.home().joinpath(
-        *usage_window_resolver.ALL_CREDENTIALS_RELATIVE_PATH_PARTS
-    )
-
-
-def _credentials_path_for_entry(entry: chain_runner.ChainEntry) -> Path:
-    if entry.credentials_path is None:
-        return _default_credentials_path()
-    return Path(entry.credentials_path).expanduser()
+    """Raised when an account's usage meters cannot be measured."""
 
 
 def _usage_pause_scripts_directory() -> Path:
@@ -104,9 +52,7 @@ def _load_resolve_usage_window_module() -> ModuleType:
     module_path = scripts_directory / RESOLVE_USAGE_WINDOW_FILENAME
     if not module_path.is_file():
         raise WeeklyUtilizationProbeError(
-            RESOLVE_USAGE_WINDOW_MISSING_ERROR_TEMPLATE.format(
-                module_path=module_path
-            )
+            RESOLVE_USAGE_WINDOW_MISSING_ERROR_TEMPLATE.format(module_path=module_path)
         )
     scripts_directory_text = str(scripts_directory)
     was_path_inserted = False
@@ -120,9 +66,7 @@ def _load_resolve_usage_window_module() -> ModuleType:
         )
         if module_specification is None or module_specification.loader is None:
             raise WeeklyUtilizationProbeError(
-                RESOLVE_USAGE_WINDOW_MISSING_ERROR_TEMPLATE.format(
-                    module_path=module_path
-                )
+                RESOLVE_USAGE_WINDOW_MISSING_ERROR_TEMPLATE.format(module_path=module_path)
             )
         loaded_module = importlib.util.module_from_spec(module_specification)
         sys.modules[RESOLVE_USAGE_WINDOW_MODULE_NAME] = loaded_module
@@ -138,13 +82,7 @@ def _load_resolve_usage_window_module() -> ModuleType:
 
 @dataclass(frozen=True)
 class AccountUsageMeters:
-    """One account's 5-hour and weekly meters, each field None when unread.
-
-    ::
-
-        {"five_hour": {"utilization": 42, ...}, "seven_day": {...}}
-        -> AccountUsageMeters(42.0, <5-hour reset>, 63.0, <weekly reset>)
-    """
+    """An account's short and weekly utilization and reset times."""
 
     session_utilization: float | None
     session_resets_at: datetime | None
@@ -157,9 +95,7 @@ def _fetch_account_usage_payload(
 ) -> dict[str, object]:
     now = datetime.now().astimezone()
     try:
-        access_token = usage_window_resolver.read_oauth_access_token(
-            credentials_path, now
-        )
+        access_token = usage_window_resolver.read_oauth_access_token(credentials_path, now)
         if access_token is None:
             raise WeeklyUtilizationProbeError(
                 NO_ACCESS_TOKEN_ERROR_TEMPLATE.format(credentials_path=credentials_path)
@@ -180,18 +116,7 @@ def _fetch_account_usage_payload(
 
 
 def probe_account_meters(credentials_path: Path) -> AccountUsageMeters:
-    """Read one account's usage meters through the usage-pause OAuth probe.
-
-    Args:
-        credentials_path: The account's CLI credential file.
-
-    Returns:
-        The account's 5-hour and weekly meters.
-
-    Raises:
-        WeeklyUtilizationProbeError: When the credential yields no usable token
-            or the probe request fails.
-    """
+    """Read short and weekly usage meters for one account."""
     usage_window_resolver = _load_resolve_usage_window_module()
     usage_payload = _fetch_account_usage_payload(usage_window_resolver, credentials_path)
     usage_windows = usage_window_resolver.extract_usage_windows(usage_payload)
@@ -201,192 +126,3 @@ def probe_account_meters(credentials_path: Path) -> AccountUsageMeters:
         weekly_utilization=usage_windows.weekly_utilization,
         weekly_resets_at=usage_windows.weekly_resets_at,
     )
-
-
-def _probe_weekly_utilization(credentials_path: Path) -> float:
-    weekly_utilization = probe_account_meters(credentials_path).weekly_utilization
-    if weekly_utilization is None:
-        raise WeeklyUtilizationProbeError(WEEKLY_UTILIZATION_MISSING_ERROR)
-    return float(weekly_utilization)
-
-
-weekly_utilization_probe: WeeklyUtilizationProbe = _probe_weekly_utilization
-
-
-def weekly_remaining_from_utilization(weekly_utilization: float) -> float:
-    """Convert weekly utilization percent into remaining weekly percent.
-
-    ::
-
-        weekly_remaining_from_utilization(42.0) -> 58.0
-        weekly_remaining_from_utilization(9.0)  -> 91.0
-
-    Args:
-        weekly_utilization: Used weekly capacity on the 0–100 scale.
-
-    Returns:
-        Remaining weekly capacity on the same 0–100 scale.
-    """
-    return FULL_WEEKLY_PERCENT - weekly_utilization
-
-
-def _report_for_entry(
-    entry: chain_runner.ChainEntry,
-    active_probe: WeeklyUtilizationProbe,
-) -> AccountUsageReport:
-    try:
-        credentials_path = _credentials_path_for_entry(entry)
-        weekly_utilization = active_probe(credentials_path)
-    except (WeeklyUtilizationProbeError, ImportError, AttributeError) as probe_error:
-        return AccountUsageReport(
-            command=entry.command,
-            weekly_remaining_percent=None,
-            error=str(probe_error),
-        )
-    return AccountUsageReport(
-        command=entry.command,
-        weekly_remaining_percent=weekly_remaining_from_utilization(
-            weekly_utilization
-        ),
-    )
-
-
-def report_chain_weekly_usage(*, config_path: Path) -> list[AccountUsageReport]:
-    """Report remaining weekly usage for every account in the chain config.
-
-    ::
-
-        report_chain_weekly_usage(config_path=Path("chain.json"))
-        -> [AccountUsageReport("claude", 58.0), ...]
-
-    Uses the module-level ``weekly_utilization_probe`` (tests rebind it).
-
-    Args:
-        config_path: Chain configuration file to load.
-
-    Returns:
-        One report per chain entry, in config order.
-
-    Raises:
-        ChainConfigurationError: When the chain configuration cannot be loaded.
-    """
-    all_entries = chain_runner.load_chain(config_path)
-    return [
-        _report_for_entry(each_entry, weekly_utilization_probe)
-        for each_entry in all_entries
-    ]
-
-
-def _nulls_last_remaining_rank(report: AccountUsageReport) -> tuple[int, float]:
-    if report.weekly_remaining_percent is None:
-        return (1, 0.0)
-    return (0, -report.weekly_remaining_percent)
-
-
-def rank_accounts_by_weekly_remaining(
-    all_reports: list[AccountUsageReport],
-) -> list[AccountUsageReport]:
-    """Order reports by remaining weekly usage, highest first.
-
-    ::
-
-        [40%, 70%, null, 70%] -> [70% (earlier), 70% (later), 40%, null]
-
-    Ties keep config order. Unmeasurable accounts (null remaining) sort last.
-
-    Args:
-        all_reports: Reports in chain-config order.
-
-    Returns:
-        A new list ordered by remaining weekly percent descending.
-    """
-    return sorted(all_reports, key=_nulls_last_remaining_rank)
-
-
-def _account_report_to_json_mapping(
-    report: AccountUsageReport,
-) -> dict[str, str | float | None]:
-    if report.weekly_remaining_percent is None:
-        return {
-            JSON_COMMAND_KEY: report.command,
-            JSON_WEEKLY_REMAINING_PERCENT_KEY: None,
-            JSON_ERROR_KEY: report.error,
-        }
-    return {
-        JSON_COMMAND_KEY: report.command,
-        JSON_WEEKLY_REMAINING_PERCENT_KEY: report.weekly_remaining_percent,
-    }
-
-
-def reports_to_json_payload(
-    all_reports: list[AccountUsageReport],
-) -> dict[str, list[dict[str, str | float | None]]]:
-    """Build the CLI JSON payload for a list of account reports.
-
-    ::
-
-        reports_to_json_payload([AccountUsageReport("claude", 58.0)])
-        -> {"accounts": [{"command": "claude", "weekly_remaining_percent": 58.0}]}
-
-    Args:
-        all_reports: Reports in the order they should appear in the payload.
-
-    Returns:
-        The ``{"accounts": [...]}`` envelope.
-    """
-    return {
-        JSON_ACCOUNTS_KEY: [
-            _account_report_to_json_mapping(each_report)
-            for each_report in all_reports
-        ]
-    }
-
-
-def _build_argument_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(
-        description=(
-            "Report remaining weekly usage for every account in the Claude chain."
-        )
-    )
-    parser.add_argument(
-        CLI_CONFIG_PATH_FLAG,
-        dest="config_path",
-        default=None,
-        help="Path to claude-chain.json; defaults to the per-user chain config.",
-    )
-    return parser
-
-
-def main(all_command_arguments: list[str]) -> int:
-    """Probe the chain and print the weekly-usage JSON report on stdout.
-
-    ::
-
-        main(["--config-path", "chain.json"]) -> 0  # JSON on stdout
-        main(["--config-path", "missing.json"]) -> 3  # error on stderr
-
-    Args:
-        all_command_arguments: The argument vector after the program name.
-
-    Returns:
-        Zero on success, or the chain-config error exit code when the config
-        cannot be loaded.
-    """
-    parser = _build_argument_parser()
-    parsed_arguments = parser.parse_args(all_command_arguments)
-    resolved_config_path = (
-        Path(parsed_arguments.config_path)
-        if parsed_arguments.config_path is not None
-        else chain_runner.chain_config_path()
-    )
-    try:
-        all_reports = report_chain_weekly_usage(config_path=resolved_config_path)
-    except chain_runner.ChainConfigurationError as configuration_error:
-        print(str(configuration_error), file=sys.stderr)
-        return CHAIN_CONFIG_ERROR_EXIT_CODE
-    print(json.dumps(reports_to_json_payload(all_reports), ensure_ascii=True))
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main(sys.argv[1:]))

package/scripts/codec_forwarding_test_support.py

@@ -1,85 +1,31 @@
-"""Shared fixtures for text-codec keyword-forwarding behavioral tests."""
+"""Shared fixtures for broker keyword forwarding tests."""
 
 from __future__ import annotations
 
-import subprocess
-from collections.abc import Sequence
-
-import claude_chain_runner as chain_runner
 import pytest
-from claude_chain_runner import ChainAttempt, ChainInvocationOutcome
-from dev_env_scripts_constants.claude_chain_constants import TERMINAL_STATUS_SERVED
+
+from dev_env_scripts_constants.account_broker_constants import JobOutcome, Product
 
 FIXTURE_ENCODING_KEYWORD_NAME = "encoding"
 FIXTURE_ERRORS_KEYWORD_NAME = "errors"
 FIXTURE_CHAIN_ENCODING = "utf-8"
 FIXTURE_CHAIN_ERRORS = "replace"
-FIXTURE_SERVED_COMMAND = "claude"
-
-
-def build_served_outcome(*, chain_stdout: str) -> ChainInvocationOutcome:
-    return ChainInvocationOutcome(
-        served_command=FIXTURE_SERVED_COMMAND,
-        returncode=0,
-        stdout=chain_stdout,
-        stderr="",
-        attempts=(ChainAttempt(command=FIXTURE_SERVED_COMMAND, status="served"),),
-        terminal_status=TERMINAL_STATUS_SERVED,
-    )
-
-
-def build_recording_runner(
-    all_observed_runner_keywords: dict[str, object],
-    *,
-    chain_stdout: str,
-) -> object:
-    def _recording_runner(
-        all_invocation_tokens: Sequence[str],
-        *all_positionals: object,
-        **all_keywords: object,
-    ) -> subprocess.CompletedProcess[str]:
-        del all_positionals
-        all_observed_runner_keywords.update(all_keywords)
-        return subprocess.CompletedProcess(
-            args=list(all_invocation_tokens),
-            returncode=0,
-            stdout=chain_stdout,
-            stderr="",
-        )
-
-    return _recording_runner
 
 
 def install_codec_seams(
     monkeypatch: pytest.MonkeyPatch,
     *,
-    all_chain_codec_keywords: dict[str, str],
     chain_stdout: str,
     runner_host: object,
     runner_attribute_name: str,
 ) -> dict[str, object]:
-    all_observed_runner_keywords: dict[str, object] = {}
+    observed_options: dict[str, object] = {}
 
-    def _fake_claude(
-        all_claude_arguments: list[str], *, timeout_seconds: int
-    ) -> ChainInvocationOutcome:
-        chain_runner.chain_subprocess_runner(
-            [FIXTURE_SERVED_COMMAND, *all_claude_arguments],
-            capture_output=True,
-            text=True,
-            timeout=timeout_seconds,
-            check=False,
-            **all_chain_codec_keywords,
-        )
-        return build_served_outcome(chain_stdout=chain_stdout)
+    def recording_runner(product: Product, argv: list[str], **options: object) -> JobOutcome:
+        assert product is Product.CLAUDE
+        assert argv[0] == "claude"
+        observed_options.update(options)
+        return JobOutcome(0, chain_stdout, "", "main", (("main", "served"),), "served", None, None)
 
-    monkeypatch.setattr(
-        chain_runner,
-        "chain_subprocess_runner",
-        build_recording_runner(
-            all_observed_runner_keywords,
-            chain_stdout=chain_stdout,
-        ),
-    )
-    monkeypatch.setattr(runner_host, runner_attribute_name, _fake_claude)
-    return all_observed_runner_keywords
+    monkeypatch.setattr(runner_host, runner_attribute_name, recording_runner)
+    return observed_options

package/scripts/dev_env_scripts_constants/claude_account_worker_constants.py

@@ -2,19 +2,8 @@
 
 from __future__ import annotations
 
-from dev_env_scripts_constants.claude_account_constants import (
-    CHOICE_MAIN,
-    CHOICE_SECOND,
-    CHOICE_WAIT,
-    CLAUDE_BINARY_NAME,
-    CREDENTIALS_FILE_NAME,
-    EXTRA_PROFILES_FILE_NAME,
-    JSON_ACCOUNT_KEY,
-    JSON_CONFIG_DIRECTORY_KEY,
-    JSON_REASON_KEY,
-    MAIN_CLAUDE_HOME_DIRECTORY_NAME,
-)
-from dev_env_scripts_constants.shared_tree_constants import CLAUDE_CONFIG_DIR_ENV_VAR
+from dev_env_scripts_constants.account_broker_constants import WAIT_EXIT_CODE
+from dev_env_scripts_constants.claude_account_constants import CLAUDE_BINARY_NAME, JSON_ACCOUNT_KEY, JSON_REASON_KEY
 
 DEFAULT_PERMISSION_MODE: str = "auto"
 
@@ -22,14 +11,14 @@ DEFAULT_TIMEOUT_MINUTES: int = 60
 
 MINIMUM_TIMEOUT_MINUTES: int = 1
 
-WAIT_EXIT_CODE: int = 3
-
 TIMEOUT_EXIT_CODE: int = 124
 
 MISSING_BINARY_EXIT_CODE: int = 127
 
 LAUNCH_FAILURE_EXIT_CODE: int = 1
 
+CONFIGURATION_FAILURE_EXIT_CODE: int = 2
+
 WAIT_DURATION_SECONDS: float = 0.0
 
 STDOUT_TAIL_CHARACTER_LIMIT: int = 4000
@@ -46,7 +35,7 @@ UTF8_ENCODING: str = "utf-8"
 
 UTF8_DECODE_ERRORS: str = "replace"
 
-CLI_DESCRIPTION: str = "Run one Claude worker using the account picker."
+CLI_DESCRIPTION: str = "Run one Claude worker through the account broker."
 
 PROMPT_FILE_FLAG: str = "--prompt-file"
 
@@ -90,28 +79,21 @@ INVALID_TIMEOUT_MESSAGE: str = "--timeout-minutes must be at least 1"
 
 
 __all__ = [
-    "CHOICE_MAIN",
-    "CHOICE_SECOND",
-    "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",
     "DRAIN_ATTEMPT_LIMIT",
     "DRAIN_GRACE_TIMEOUT_SECONDS",
     "DURATION_DECIMAL_PLACES",
-    "EXTRA_PROFILES_FILE_NAME",
     "INVALID_TIMEOUT_MESSAGE",
     "JSON_ACCOUNT_KEY",
-    "JSON_CONFIG_DIRECTORY_KEY",
     "JSON_IS_ERROR_KEY",
     "JSON_REASON_KEY",
     "JSON_RESULT_KEY",
     "LAUNCH_FAILURE_EXIT_CODE",
-    "MAIN_CLAUDE_HOME_DIRECTORY_NAME",
     "MISSING_BINARY_EXIT_CODE",
     "MINIMUM_TIMEOUT_MINUTES",
     "MODEL_FLAG",