code-coordinator 0.5.52__tar.gz → 0.5.53__tar.gz

{code_coordinator-0.5.52/code_coordinator.egg-info → code_coordinator-0.5.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.52
+Version: 0.5.53
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.52 → code_coordinator-0.5.53/code_coordinator.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.52
+Version: 0.5.53
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.52 → code_coordinator-0.5.53}/code_coordinator.egg-info/SOURCES.txt

@@ -640,6 +640,7 @@ tests/test_providers.py
 tests/test_providers_config_labels.py
 tests/test_providers_pty.py
 tests/test_quiet_hours.py
+tests/test_quiet_hours_store_2146.py
 tests/test_reap_merged_sessions.py
 tests/test_reap_stale_interactive_tick.py
 tests/test_reconcile_branch.py

{code_coordinator-0.5.52 → code_coordinator-0.5.53}/code_coordinator.egg-info/scm_file_list.json

@@ -670,6 +670,7 @@
     "tests/test_providers_config_labels.py",
     "tests/test_providers_pty.py",
     "tests/test_quiet_hours.py",
+    "tests/test_quiet_hours_store_2146.py",
     "tests/test_reap_merged_sessions.py",
     "tests/test_reap_stale_interactive_tick.py",
     "tests/test_reconcile_branch.py",

{code_coordinator-0.5.52 → code_coordinator-0.5.53}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.52",
+  "tag": "0.5.53",
   "distance": 0,
-  "node": "g330dc07157c3cfc0656c8d93b6c7d8a59ca29394",
+  "node": "gfdb2b81a9b6878d9dd5c755ea92fbc5de7839f21",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-13"

{code_coordinator-0.5.52 → code_coordinator-0.5.53}/coord/cli.py

@@ -55,7 +55,7 @@ from coord.commands.setup import (
     install_skills,
     version,
 )
-from coord.commands.agent_ops import agent, pause, unpause
+from coord.commands.agent_ops import agent, pause, quiet_hours, unpause
 from coord.commands.gates import gates
 from coord.commands.status import diagnose, doctor, show_plan, status, usage
 from coord.commands.dispatch import (
@@ -376,6 +376,8 @@ main.add_command(bounce)
 main.add_command(sync)
 main.add_command(pause)
 main.add_command(unpause)
+# #2146: set a machine's quiet-hours window without a coordinator session.
+main.add_command(quiet_hours)
 main.add_command(refine_chat)
 main.add_command(test_chat)
 main.add_command(new_issue_chat)

{code_coordinator-0.5.52 → code_coordinator-0.5.53}/coord/client.py

@@ -283,6 +283,65 @@ def post_cordon(
     return post_record(svc, "/pause", payload, timeout=timeout)
 
 
+def fetch_quiet_hours(
+    svc: ServiceConfig, *, timeout: float = _DEFAULT_TIMEOUT
+) -> dict[str, dict]:
+    """GET /pause → the daemon's effective quiet-hours windows (#2146).
+
+    ``{machine: {start, end, tz, source}}`` for every machine with a window,
+    whether it currently covers "now" or not — a thin client needs the whole
+    map to render `coord quiet-hours --list` and to pre-fill a dialog, not
+    just the subset that happens to be active this minute.
+
+    ``{}`` when the daemon predates #2146 (the key is simply absent), which
+    is the right read for a daemon that has no operator-set store. Raises
+    ``httpx.HTTPError`` on transport/HTTP failure —
+    `coord.machine_pause.effective_quiet_hours()` catches that and degrades
+    to "no windows known", the same fail-soft read posture as
+    `fetch_paused_machines`.
+    """
+    resp = httpx.get(f"{svc.url}/pause", headers=_headers(svc), timeout=timeout)
+    resp.raise_for_status()
+    data = resp.json()
+    rows = data.get("quiet_hours") if isinstance(data, dict) else None
+    if not isinstance(rows, dict):
+        return {}
+    return {str(k): dict(v) for k, v in rows.items() if isinstance(v, dict)}
+
+
+def post_quiet_hours(
+    svc: ServiceConfig,
+    machine: str,
+    action: str,
+    *,
+    start: str | None = None,
+    end: str | None = None,
+    tz: str | None = None,
+    timeout: float = _WRITE_TIMEOUT,
+) -> dict:
+    """POST /pause {machine, action: set-quiet|clear-quiet, ...} (#2146).
+
+    Deliberately the SAME endpoint as pause/cordon: a quiet-hours window is
+    the same routing decision on a schedule, and one endpoint means one
+    place a thin client can be wrong about it.
+
+    Raises ``httpx.HTTPError`` on transport/HTTP failure — the whole point
+    of #2146 is that a thin client cannot edit `coordinator.yml` (its copy
+    is an overwritten cache), so a write that reported success and reached
+    nothing would rebuild the exact bug this closes. A daemon that predates
+    #2146 answers 400 ``unknown action``, which surfaces here as an
+    ``HTTPStatusError`` rather than a silent no-op: deploy the daemon first.
+    """
+    payload: dict = {"machine": machine, "action": action}
+    if start is not None:
+        payload["start"] = start
+    if end is not None:
+        payload["end"] = end
+    if tz is not None:
+        payload["tz"] = tz
+    return post_record(svc, "/pause", payload, timeout=timeout)
+
+
 def post_pause(
     svc: ServiceConfig, machine: str, action: str, *, timeout: float = _WRITE_TIMEOUT
 ) -> dict:

{code_coordinator-0.5.52 → code_coordinator-0.5.53}/coord/commands/agent_ops.py

@@ -1386,4 +1386,253 @@ def unpause(config_path: Path, machine: str) -> None:
             f"({outcome.tz}) — resumes its normal quiet schedule next window"
         )
     else:
-        click.echo(f"not paused: {machine}")
+        click.echo(f"not paused: {machine}")
+
+
+# ── #2146: `coord quiet-hours` ──────────────────────────────────────────────
+
+
+def _local_tz_name() -> str | None:
+    """The CLIENT's IANA zone name, or None if it can't be determined.
+
+    #2146: `--tz` must default to the operator's own zone — they mean "22:00
+    MY time", and the daemon runs UTC, so defaulting to the daemon's clock
+    would fire hours off. `datetime.now().astimezone().tzinfo` gives an
+    ABBREVIATION ("CDT"), not an IANA name `ZoneInfo` can resolve, so this
+    walks the usual POSIX sources first and only falls back to that.
+
+    Returning None (rather than guessing "UTC") is deliberate: the caller
+    turns it into "pass --tz explicitly", because a silently-UTC window is
+    exactly the wrong-hour failure #1862 made `tz` mandatory to prevent.
+    """
+    from zoneinfo import ZoneInfo  # noqa: PLC0415
+
+    def _ok(name: str | None) -> str | None:
+        if not name or name in ("localtime", "UTC0"):
+            return None
+        try:
+            ZoneInfo(name)
+        except Exception:  # noqa: BLE001 — not a resolvable zone, try the next source
+            return None
+        return name
+
+    candidates: list[str | None] = [os.environ.get("TZ")]
+    try:
+        candidates.append(Path("/etc/timezone").read_text(encoding="utf-8").strip())
+    except OSError:
+        pass
+    try:
+        parts = Path("/etc/localtime").resolve().parts
+        if "zoneinfo" in parts:
+            candidates.append("/".join(parts[parts.index("zoneinfo") + 1:]))
+    except OSError:
+        pass
+    from datetime import datetime as _dt  # noqa: PLC0415
+
+    candidates.append(_dt.now().astimezone().tzname())
+    for candidate in candidates:
+        resolved = _ok(candidate)
+        if resolved is not None:
+            return resolved
+    return None
+
+
+def _parse_window_arg(window: str) -> tuple[str, str]:
+    """``"22:00-08:00"`` → ``("22:00", "08:00")``. Shape only — the real
+    validation (HH:MM, IANA tz, start != end) is `coord.config`'s, so the
+    CLI can never accept a window `coordinator.yml` would reject."""
+    parts = window.split("-")
+    if len(parts) != 2 or not parts[0].strip() or not parts[1].strip():
+        raise ValueError(
+            f"window must look like '22:00-08:00', got {window!r}"
+        )
+    return parts[0].strip(), parts[1].strip()
+
+
+def _quiet_hours_rows(machines: Any) -> dict[str, dict]:
+    from coord.machine_pause import effective_quiet_hours  # noqa: PLC0415
+
+    return effective_quiet_hours(machines)
+
+
+def _describe_source(source: str) -> str:
+    return "set here" if source == "store" else "coordinator.yml"
+
+
+@click.command(
+    "quiet-hours",
+    help=(
+        "Show or set a machine's recurring no-new-dispatch window (#2146).\n\n"
+        "\b\n"
+        "  coord quiet-hours MACHINE 22:00-08:00 [--tz America/Chicago]\n"
+        "  coord quiet-hours MACHINE --clear\n"
+        "  coord quiet-hours [MACHINE] --list\n"
+        "  coord quiet-hours MACHINE --print-yaml\n\n"
+        "A window set here is stored on the DAEMON (alongside pauses and "
+        "release cordons) and overrides that machine's coordinator.yml "
+        "`quiet_hours:` block entirely — it does not rewrite the YAML. "
+        "`--print-yaml` emits a paste-ready block for when a window should "
+        "become permanent and version-controlled.\n\n"
+        "--tz defaults to THIS machine's zone, never the daemon's UTC, and "
+        "the resolved zone is echoed back so a wrong default is visible "
+        "immediately."
+    ),
+)
+
+
+@_CONFIG_OPTION
+@click.argument("machine", required=False)
+@click.argument("window", required=False)
+@click.option("--tz", "tz", default=None, help="IANA zone (default: this machine's).")
+@click.option("--clear", "clear_", is_flag=True, help="Remove an operator-set window.")
+@click.option("--list", "list_", is_flag=True, help="Show windows and where they came from.")
+@click.option(
+    "--print-yaml",
+    "print_yaml",
+    is_flag=True,
+    help="Emit a coordinator.yml `quiet_hours:` block for MACHINE.",
+)
+def quiet_hours(
+    config_path: Path,
+    machine: str | None,
+    window: str | None,
+    tz: str | None,
+    clear_: bool,
+    list_: bool,
+    print_yaml: bool,
+) -> None:
+    from coord.machine_pause import clear_quiet_hours, set_quiet_hours  # noqa: PLC0415
+
+    # Best-effort config, exactly like `unpause` above: an unloadable config
+    # must not block the (fully functional) store path — it only means
+    # coordinator.yml-sourced windows can't be listed alongside store ones.
+    machines = None
+    try:
+        from coord.config import load as _load_yaml_config  # noqa: PLC0415
+
+        machines = _load_yaml_config(config_path).machines
+    except Exception:  # noqa: BLE001
+        pass
+
+    if list_ or (machine is None and not (clear_ or print_yaml or window)):
+        rows = _quiet_hours_rows(machines)
+        if machine is not None:
+            rows = {k: v for k, v in rows.items() if k == machine}
+        if not rows:
+            click.echo(
+                "no quiet hours set"
+                + (f" for {machine}" if machine else "")
+                + " (set one: coord quiet-hours MACHINE 22:00-08:00)"
+            )
+            return
+        width = max(len(name) for name in rows)
+        for name, row in sorted(rows.items()):
+            click.echo(
+                f"{name.ljust(width)}  {row.get('start')}-{row.get('end')}  "
+                f"{row.get('tz')}  [{_describe_source(str(row.get('source') or ''))}]"
+            )
+        return
+
+    if machine is None:
+        click.echo("error: MACHINE is required", err=True)
+        sys.exit(2)
+
+    if print_yaml:
+        # The promotion path: a window that has proved itself belongs in
+        # version control, where a daemon rebuild can't lose it.
+        if window is not None:
+            try:
+                start, end = _parse_window_arg(window)
+            except ValueError as e:
+                click.echo(f"error: {e}", err=True)
+                sys.exit(2)
+            zone = tz or _local_tz_name()
+        else:
+            row = _quiet_hours_rows(machines).get(machine)
+            if row is None:
+                click.echo(
+                    f"error: no quiet hours known for {machine!r} — pass a window "
+                    "(e.g. `coord quiet-hours MACHINE 22:00-08:00 --print-yaml`)",
+                    err=True,
+                )
+                sys.exit(1)
+            start, end, zone = row.get("start"), row.get("end"), tz or row.get("tz")
+        if not zone:
+            click.echo(
+                "error: could not determine a time zone — pass --tz "
+                "(e.g. --tz America/Chicago)",
+                err=True,
+            )
+            sys.exit(2)
+        click.echo(f"  # machines[] entry for {machine!r} in coordinator.yml")
+        click.echo("  quiet_hours:")
+        click.echo(f'    start: "{start}"')
+        click.echo(f'    end: "{end}"')
+        click.echo(f'    tz: "{zone}"')
+        return
+
+    if clear_:
+        # #2146 acceptance: "nothing set" is NOT success. A machine can still
+        # have a coordinator.yml block this cannot touch, and reporting
+        # "cleared" for a no-op is the failure class this feature exists to
+        # avoid.
+        try:
+            changed = clear_quiet_hours(machine)
+        except Exception as e:  # noqa: BLE001
+            click.echo(
+                f"error: could not confirm clearing quiet hours for {machine!r} "
+                f"with the daemon: {e}",
+                err=True,
+            )
+            sys.exit(1)
+        if not changed:
+            click.echo(f"nothing set: {machine} has no operator-set quiet hours")
+            return
+        click.echo(f"cleared: {machine} quiet hours")
+        row = _quiet_hours_rows(machines).get(machine)
+        if row is not None:
+            click.echo(
+                f"note: {machine} still has a coordinator.yml window "
+                f"{row.get('start')}-{row.get('end')} ({row.get('tz')})"
+            )
+        return
+
+    if window is None:
+        click.echo(
+            "error: pass a window (e.g. `coord quiet-hours MACHINE 22:00-08:00`), "
+            "--clear, --list or --print-yaml",
+            err=True,
+        )
+        sys.exit(2)
+    try:
+        start, end = _parse_window_arg(window)
+    except ValueError as e:
+        click.echo(f"error: {e}", err=True)
+        sys.exit(2)
+    zone = tz or _local_tz_name()
+    if not zone:
+        click.echo(
+            "error: could not determine this machine's time zone — pass --tz "
+            "(e.g. --tz America/Chicago). Quiet hours never default to the "
+            "daemon's UTC clock: it would fire at the wrong local hour.",
+            err=True,
+        )
+        sys.exit(2)
+
+    # #1563/#2146: fail loudly. A thin client's write that never reaches the
+    # daemon must not print a confirmation.
+    try:
+        stored = set_quiet_hours(machine, start=start, end=end, tz=zone)
+    except Exception as e:  # noqa: BLE001
+        click.echo(
+            f"error: could not set quiet hours for {machine!r}: {e}",
+            err=True,
+        )
+        sys.exit(1)
+    # Echo the RESOLVED zone: a wrong `--tz` default is otherwise invisible
+    # until the machine goes quiet at the wrong hour.
+    click.echo(
+        f"quiet hours set: {machine} {stored.get('start')}-{stored.get('end')} "
+        f"({stored.get('tz')}) — overrides any coordinator.yml block for this "
+        f"machine; `coord quiet-hours {machine} --print-yaml` to make it permanent"
+    )

{code_coordinator-0.5.52 → code_coordinator-0.5.53}/coord/commands/status.py

@@ -130,13 +130,21 @@ def status(config_path: Path, machine_filter: str | None, no_reconcile: bool, ti
     # render "PAUSED" for a machine nobody paused and no `coord unpause` will
     # free — work stopping with no stated reason, which is the exact failure
     # the cordon mechanism is supposed to stop repeating.
+    # #2146: an operator-SET quiet-hours window lives in the daemon's state
+    # file, not in coordinator.yml, so a thin client resolving it locally
+    # would see the machine in `paused` with no local explanation and print
+    # the flatly wrong "PAUSED". Fetch the effective window map (daemon-aware,
+    # fail-soft) and hand it to describe_pause_state, which also names where
+    # each window came from — "set here" vs "from coordinator.yml".
     from coord.machine_pause import (  # noqa: PLC0415
         cordons as fetch_cordons,
         describe_pause_state,
+        effective_quiet_hours,
         paused_set,
     )
     paused = paused_set(cfg.machines)
     cordons = fetch_cordons()
+    quiet_windows = effective_quiet_hours(cfg.machines)
 
     statuses = check_all(machines, timeout=timeout)
     agent_completed: dict[str, dict] = {}
@@ -196,7 +204,9 @@ def status(config_path: Path, machine_filter: str | None, no_reconcile: bool, ti
         # pause — an operator debugging a stalled queue at 1AM needs to
         # know whether the machine will wake itself up or is waiting on
         # `coord unpause`.
-        pause_state = describe_pause_state(m, paused, cordons=cordons)
+        pause_state = describe_pause_state(
+            m, paused, cordons=cordons, quiet_hours=quiet_windows
+        )
         if pause_state is not None and pause_state.kind == "cordon":
             # #2101 trap E: name the version it is draining for, so a stopped
             # machine reads as "the fleet is upgrading itself" rather than as

{code_coordinator-0.5.52 → code_coordinator-0.5.53}/coord/config.py

@@ -1951,6 +1951,50 @@ def _parse_hhmm(raw: Any, *, field_path: str) -> time:
     return time(int(m.group(1)), int(m.group(2)))
 
 
+def parse_quiet_hours_window(
+    start: Any, end: Any, tz: Any, *, prefix: str = "quiet_hours"
+) -> QuietHours:
+    """Validate a raw ``start``/``end``/``tz`` triple into a `QuietHours`.
+
+    #2146: THE definition of "a valid quiet-hours window", shared by the
+    YAML path (`_parse_quiet_hours_block` below, i.e.
+    ``machines[i].quiet_hours`` and ``notifications.quiet_hours``) and by
+    the operator-set store path (`coord.machine_pause.local_set_quiet_hours`,
+    written by `coord quiet-hours` / the daemon's `/pause` endpoint).
+
+    The two sources must never diverge on what they accept: a window a
+    `coord quiet-hours` call takes but `coordinator.yml` rejects (or vice
+    versa) would make `--print-yaml`'s promotion path — the whole point of
+    which is "make this temporary window permanent" — emit a block that
+    fails to load. One validator, one answer.
+
+    Raises `ConfigError` (with *prefix* naming the offending field) on
+    anything invalid; the daemon endpoint relays that message verbatim in
+    its 400 so an operator sees the real reason, not "bad request".
+    """
+    parsed_start = _parse_hhmm(start, field_path=f"{prefix}.start")
+    parsed_end = _parse_hhmm(end, field_path=f"{prefix}.end")
+
+    if not tz or not isinstance(tz, str):
+        raise ConfigError(
+            f"{prefix}.tz is required (IANA zone name, e.g. 'America/Chicago') — "
+            "quiet hours never default to the daemon's own UTC clock, since that "
+            "would silently fire at the wrong local hour"
+        )
+    try:
+        ZoneInfo(tz)
+    except (ZoneInfoNotFoundError, ValueError, OSError) as e:
+        raise ConfigError(f"{prefix}.tz {tz!r} is not a known IANA zone name: {e}") from e
+
+    if parsed_start == parsed_end:
+        raise ConfigError(
+            f"{prefix}: start and end must differ ('always quiet' is ambiguous — "
+            "use `coord pause` to take a machine out of rotation indefinitely instead)"
+        )
+
+    return QuietHours(start=parsed_start, end=parsed_end, tz=tz)
+
+
 def _parse_quiet_hours_block(raw: Any, *, prefix: str) -> QuietHours | None:
     """Parse a ``{start, end, tz}`` quiet-hours mapping. ``None`` → ``None``.
 
@@ -1967,34 +2011,19 @@ def _parse_quiet_hours_block(raw: Any, *, prefix: str) -> QuietHours | None:
     operator wrote — a quiet-hours feature that activates early is worse
     than none, because it silently pulls the machine out of the fleet
     during the working day. Fail loudly here rather than default quietly.
+
+    #2146: the field-level rules themselves now live in
+    `parse_quiet_hours_window` above, so the operator-set store validates
+    identically to this YAML path.
     """
     if raw is None:
         return None
     if not isinstance(raw, dict):
         raise ConfigError(f"{prefix} must be a mapping")
 
-    start = _parse_hhmm(raw.get("start"), field_path=f"{prefix}.start")
-    end = _parse_hhmm(raw.get("end"), field_path=f"{prefix}.end")
-
-    tz = raw.get("tz")
-    if not tz or not isinstance(tz, str):
-        raise ConfigError(
-            f"{prefix}.tz is required (IANA zone name, e.g. 'America/Chicago') — "
-            "quiet hours never default to the daemon's own UTC clock, since that "
-            "would silently fire at the wrong local hour"
-        )
-    try:
-        ZoneInfo(tz)
-    except (ZoneInfoNotFoundError, ValueError, OSError) as e:
-        raise ConfigError(f"{prefix}.tz {tz!r} is not a known IANA zone name: {e}") from e
-
-    if start == end:
-        raise ConfigError(
-            f"{prefix}: start and end must differ ('always quiet' is ambiguous — "
-            "use `coord pause` to take a machine out of rotation indefinitely instead)"
-        )
-
-    return QuietHours(start=start, end=end, tz=tz)
+    return parse_quiet_hours_window(
+        raw.get("start"), raw.get("end"), raw.get("tz"), prefix=prefix
+    )
 
 
 def _parse_quiet_hours(raw: Any, *, machine_index: int, machine_name: str) -> QuietHours | None: