code-coordinator 0.5.514__tar.gz → 0.5.516__tar.gz

{code_coordinator-0.5.514 → code_coordinator-0.5.516}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.514
+Version: 0.5.516
 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.514 → code_coordinator-0.5.516}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.514
+Version: 0.5.516
 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.514 → code_coordinator-0.5.516}/code_coordinator.egg-info/SOURCES.txt

@@ -265,6 +265,7 @@ coord/health/checks/graph.py
 coord/health/checks/graphify_cli.py
 coord/health/checks/index_lock.py
 coord/health/checks/issues_sync_staleness.py
+coord/health/checks/local_machine_identity.py
 coord/health/checks/plan_usage.py
 coord/health/checks/pr_churn.py
 coord/health/checks/release_cordon.py
@@ -685,6 +686,7 @@ tests/test_human_attended_437.py
 tests/test_init.py
 tests/test_install_agent_venv_2911.py
 tests/test_integration.py
+tests/test_interactive.py
 tests/test_interactive_briefing_echo.py
 tests/test_interactive_pane_log_2541.py
 tests/test_interactive_prefill_state.py

{code_coordinator-0.5.514 → code_coordinator-0.5.516}/code_coordinator.egg-info/scm_file_list.json

@@ -174,6 +174,7 @@
     "coord/health/checks/graphify_cli.py",
     "coord/health/checks/index_lock.py",
     "coord/health/checks/issues_sync_staleness.py",
+    "coord/health/checks/local_machine_identity.py",
     "coord/health/checks/plan_usage.py",
     "coord/health/checks/pr_churn.py",
     "coord/health/checks/release_cordon.py",
@@ -711,6 +712,7 @@
     "tests/test_init.py",
     "tests/test_install_agent_venv_2911.py",
     "tests/test_integration.py",
+    "tests/test_interactive.py",
     "tests/test_interactive_briefing_echo.py",
     "tests/test_interactive_pane_log_2541.py",
     "tests/test_interactive_prefill_state.py",

code_coordinator-0.5.516/code_coordinator.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.516",
+  "distance": 0,
+  "node": "g19a9eb87ca92b056b9d5bfed8273bb8f83a30fa0",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-24"
+}

{code_coordinator-0.5.514 → code_coordinator-0.5.516}/coord/ci_store.py

@@ -539,6 +539,25 @@ CI_RERUN_POLL_INTERVAL_SECONDS = 10.0
 CI_RERUN_MAX_WAIT_SECONDS = 360.0
 
 
+def is_unreadable_check_name(name: str) -> bool:
+    """The name-only half of :func:`is_unreadable_check` (#3438).
+
+    Split out so a caller holding only a bare check *name* — not a full
+    ``CheckRun`` with a ``.conclusion`` — can still recognize the #1525
+    synthetic stand-in. This is exactly the shape of
+    ``QueuedMerge.ci_seen_check_names_json`` (:mod:`coord.merge_queue`'s
+    #3263 shrinkage guard persists names, not whole ``CheckRun`` objects),
+    so a row poisoned before #3438's write-side fix — one whose stored JSON
+    already contains a synthetic name — can be filtered on *read* too,
+    recovering in place rather than needing manual DB repair.
+
+    One question, one answer: :func:`is_unreadable_check` delegates here for
+    its own name check rather than re-deriving the same prefix/substring
+    test, so the two can never drift apart.
+    """
+    return name.startswith("coord: ") and "read CI status" in name
+
+
 def is_unreadable_check(check) -> bool:
     """True for the #1525 synthetic "could not read CI status" / "gh too
     old" stand-ins (``coord.ci_github._unreadable_check`` /
@@ -570,11 +589,7 @@ def is_unreadable_check(check) -> bool:
     than the prose these three call sites already commit to.
     """
     name = str(getattr(check, "name", ""))
-    return (
-        getattr(check, "conclusion", None) == "unknown"
-        and name.startswith("coord: ")
-        and "read CI status" in name
-    )
+    return getattr(check, "conclusion", None) == "unknown" and is_unreadable_check_name(name)
 
 
 @dataclass

{code_coordinator-0.5.514 → code_coordinator-0.5.516}/coord/commands/dispatch.py

@@ -6,7 +6,6 @@ Extracted from coord/cli.py (#747)."""
 from __future__ import annotations
 
 import dataclasses
-import socket
 import sys
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -1498,7 +1497,7 @@ def assign(
     if interactive:
         setup = _build_interactive_launch_setup(
             machine=machine, repo=repo, issue=issue, machine_obj=machine_obj,
-            dry_run=dry_run,
+            dry_run=dry_run, config=cfg,
         )
         provider = setup.provider
         _is_local = setup.is_local
@@ -1635,6 +1634,7 @@ def _build_interactive_launch_setup(
     issue: int,
     machine_obj: object,
     dry_run: bool,
+    config: object,
 ) -> _InteractiveLaunchSetup:
     # #2086: the authoritative gate — see _require_interactive_tty's
     # docstring. Every --interactive flavour in BOTH callers (assign()'s
@@ -1668,13 +1668,13 @@ def _build_interactive_launch_setup(
         )
 
     # Detect whether the target machine is the local machine so we can
-    # choose the local TTY path vs the remote SSH+tmux path (#494).
-    # Mirrors the hostname-matching logic in _save_config_snapshot.
-    _local_hn = socket.gethostname().split(".")[0].lower()
-    _is_local = (
-        machine_obj.name.lower() == _local_hn
-        or machine_obj.host.split(".")[0].lower() == _local_hn
-    )
+    # choose the local TTY path vs the remote SSH+tmux path (#494). Routed
+    # through the single shared resolver (#3440) — alias list, Tailscale
+    # identity, then hostname fallback, not a private hostname comparison.
+    from coord.config import resolve_local_machine  # noqa: PLC0415
+
+    _resolved_local = resolve_local_machine(config)
+    _is_local = _resolved_local is not None and _resolved_local.name == machine_obj.name
 
     # #590/#749: on a thin client the local board/DB is empty, so resolve the
     # interactive-launch target (--review-of/--fix-of/--rework-of/--smoke-of/

{code_coordinator-0.5.514 → code_coordinator-0.5.516}/coord/commands/release.py

@@ -2461,16 +2461,15 @@ def _uncordon_hosts(hosts: list[str], journal: dict, *, quiet: bool = False) ->
 
 
 def _local_machine_name(config) -> str | None:
-    """This host's name in ``coordinator.yml``, if it is in there at all."""
-    import socket  # noqa: PLC0415
+    """This host's name in ``coordinator.yml``, if it is in there at all.
 
-    here = socket.gethostname().split(".")[0].lower()
-    for machine in getattr(config, "machines", ()) or ():
-        if machine.name.lower() == here:
-            return machine.name
-        if str(getattr(machine, "host", "")).split(".")[0].lower() == here:
-            return machine.name
-    return None
+    Routes through :func:`coord.config.resolve_local_machine` (#3440) rather
+    than a private hostname comparison — "one question, one answer".
+    """
+    from coord.config import resolve_local_machine  # noqa: PLC0415
+
+    resolved = resolve_local_machine(config)
+    return resolved.name if resolved is not None else None
 
 
 def _roll_python(machine, *, target_version: str, agent_port: int, timeout: float,

{code_coordinator-0.5.514 → code_coordinator-0.5.516}/coord/commands/sessions.py

@@ -6,7 +6,6 @@ from __future__ import annotations
 import fnmatch
 import os
 import shutil
-import socket
 import subprocess
 import sys
 import time
@@ -561,11 +560,10 @@ def pull_artifact(
     # rsync-over-ssh to our own hostname FAILS ("Permission denied" — no
     # self-ssh key), which surfaced as a meaningless pull error in the TUI.
     # Copy locally if the destination differs; otherwise it is a no-op.
-    local_hostname = socket.gethostname().split(".")[0].lower()
-    is_local = (
-        machine.name.lower() == local_hostname
-        or machine.host.split(".")[0].lower() == local_hostname
-    )
+    from coord.config import resolve_local_machine  # noqa: PLC0415
+
+    _resolved_local = resolve_local_machine(cfg)
+    is_local = _resolved_local is not None and _resolved_local.name == machine.name
     if is_local:
         src_dir = Path.home() / ".coord" / "artifacts" / repo_name / sanitized
         # Nothing to copy when the destination IS the stash directory
@@ -678,8 +676,8 @@ def _prune_dead_sessions(enriched: "list[dict]", config_path: "Path") -> None:
     from coord.state import COORD_DIR, get_connection  # noqa: PLC0415
     from coord.agent import _commits_ahead  # noqa: PLC0415
     from coord.interactive import tmux_session_name  # noqa: PLC0415
+    from coord.config import resolve_local_machine  # noqa: PLC0415
 
-    _local_hn = socket.gethostname().split(".")[0].lower()
     worktrees_dir = COORD_DIR / "worktrees"
     now = time.time()
 
@@ -688,9 +686,11 @@ def _prune_dead_sessions(enriched: "list[dict]", config_path: "Path") -> None:
         cfg = _load_config(config_path)
         machines_by_name = {m.name: m for m in cfg.machines}
         repos_by_name = {r.name: r for r in cfg.repos}
+        _resolved_local = resolve_local_machine(cfg)
     except Exception:  # noqa: BLE001
         machines_by_name = {}
         repos_by_name = {}
+        _resolved_local = None
 
     pruned = 0
     for s in enriched:
@@ -703,8 +703,7 @@ def _prune_dead_sessions(enriched: "list[dict]", config_path: "Path") -> None:
             mobj = machines_by_name.get(raw_machine)
             if mobj is not None:
                 _is_local = (
-                    mobj.name.lower() == _local_hn
-                    or mobj.host.split(".")[0].lower() == _local_hn
+                    _resolved_local is not None and _resolved_local.name == mobj.name
                 )
             else:
                 # Machine name set but not in config — treat as remote to be safe.
@@ -887,14 +886,13 @@ def sessions_cmd(
         import concurrent.futures as _cf  # noqa: PLC0415
 
         try:
+            from coord.config import resolve_local_machine  # noqa: PLC0415
+
             _cfg = _load_config(config_path)
-            _local_hn = socket.gethostname().split(".")[0].lower()
+            _resolved_local = resolve_local_machine(_cfg)
             _remotes = [
                 m for m in _cfg.machines
-                if not (
-                    m.name.lower() == _local_hn
-                    or m.host.split(".")[0].lower() == _local_hn
-                )
+                if _resolved_local is None or m.name != _resolved_local.name
             ]
         except Exception:  # noqa: BLE001
             _remotes = []
@@ -1275,10 +1273,12 @@ def reattach(assignment_id: str, config_path: Path) -> None:
                         else ("$HOME" if rp == "~" else rp)
                     )
                 ssh_target_val = machine_obj.host
-                _local_hn = socket.gethostname().split(".")[0].lower()
+                from coord.config import resolve_local_machine  # noqa: PLC0415
+
+                _resolved_local = resolve_local_machine(cfg)
                 is_local_session = (
-                    machine_obj.name.lower() == _local_hn
-                    or machine_obj.host.split(".")[0].lower() == _local_hn
+                    _resolved_local is not None
+                    and _resolved_local.name == machine_obj.name
                 )
     except Exception:  # noqa: BLE001
         pass
@@ -1904,12 +1904,13 @@ def watch(
         sys.exit(2)
 
     # ── Detect whether the assignment lives on a remote agent ────────────
+    from coord.config import resolve_local_machine  # noqa: PLC0415
+
     machine_name = record.get("machine_name", "")
     machine = next((m for m in cfg.machines if m.name == machine_name), None)
-    hostname = socket.gethostname().split(".")[0]
+    _resolved_local = resolve_local_machine(cfg)
     is_remote = machine is not None and (
-        machine.name != hostname
-        and machine.host.split(".")[0] != hostname
+        _resolved_local is None or _resolved_local.name != machine.name
     )
 
     if is_remote:

{code_coordinator-0.5.514 → code_coordinator-0.5.516}/coord/commands/terminal.py

@@ -29,12 +29,17 @@ import subprocess
 import sys
 from datetime import datetime, timezone
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 import click
 
 from coord.commands._common import _CONFIG_OPTION, _load_config
 from coord.interactive import TERM_SESSION_PREFIX, TmuxHost, tmux_available, tmux_session_alive
 
+if TYPE_CHECKING:
+    from coord.config import Config
+    from coord.models import Machine
+
 __all__ = [
     "terminal_group",
     "terminal_session_name",
@@ -129,9 +134,17 @@ def _local_short_hostname() -> str:
     return socket.gethostname().split(".")[0].lower()
 
 
-def _is_local_machine(name: str, host: str) -> bool:
-    local_hn = _local_short_hostname()
-    return name.lower() == local_hn or host.split(".")[0].lower() == local_hn
+def _is_local_machine(cfg: "Config", machine: "Machine") -> bool:
+    """Is *machine* the host this process is running on?
+
+    Routes through :func:`coord.config.resolve_local_machine` (#3440) — the
+    shared "is this the local machine or must I SSH?" answer — rather than a
+    private hostname comparison.
+    """
+    from coord.config import resolve_local_machine  # noqa: PLC0415
+
+    resolved = resolve_local_machine(cfg)
+    return resolved is not None and resolved.name == machine.name
 
 
 def _resolve_machine_host(
@@ -153,7 +166,7 @@ def _resolve_machine_host(
         click.echo(f"error: machine {machine_name!r} not in config", err=True)
         sys.exit(1)
 
-    if _is_local_machine(machine.name, machine.host):
+    if _is_local_machine(cfg, machine):
         return TmuxHost(ssh_target=None), machine.name
     return TmuxHost(ssh_target=machine.host), machine.name
 
@@ -261,7 +274,7 @@ def terminal_list(output_json: bool, remote: bool, config_path: Path) -> None:
     local_host_str = local_hn
     if cfg is not None:
         m = next(
-            (mm for mm in cfg.machines if _is_local_machine(mm.name, mm.host)), None
+            (mm for mm in cfg.machines if _is_local_machine(cfg, mm)), None
         )
         if m is not None:
             local_machine_name = m.name
@@ -274,7 +287,7 @@ def terminal_list(output_json: bool, remote: bool, config_path: Path) -> None:
 
     if remote and cfg is not None:
         remotes = [
-            m for m in cfg.machines if not _is_local_machine(m.name, m.host)
+            m for m in cfg.machines if not _is_local_machine(cfg, m)
         ]
         if remotes:
             import concurrent.futures as _cf  # noqa: PLC0415

{code_coordinator-0.5.514 → code_coordinator-0.5.516}/coord/config.py

@@ -3,9 +3,15 @@
 from __future__ import annotations
 
 import fnmatch
+import json
 import os
 import re
+import socket
+import subprocess
 import sys
+# `from datetime import time` below shadows the stdlib `time` module in this
+# namespace, so the monotonic clock is imported under an explicit alias.
+import time as time_module
 from dataclasses import dataclass, field, fields
 from datetime import time
 from pathlib import Path
@@ -2408,6 +2414,192 @@ class Config:
         return next((r for r in self.repos if r.name == name), None)
 
 
+def _local_short_hostname() -> str:
+    """The OS short hostname (split on '.', lowercased).
+
+    Isolated so tests can patch ``coord.config._local_short_hostname``
+    without monkey-patching the global ``socket`` module. This is the
+    lowest-priority signal :func:`resolve_local_machine` consults — see
+    its docstring.
+    """
+    return socket.gethostname().split(".")[0].lower()
+
+
+def _tailscale_self_dns_name(*, timeout: float = 3.0) -> str | None:
+    """This host's Tailscale DNS name via ``tailscale status --self --json``,
+    or ``None`` when it can't be determined.
+
+    ``Self.DNSName`` (falling back to ``Self.HostName``) is exactly what a
+    machine's ``host:`` is set FROM in a Tailscale fleet (#3440) — e.g.
+    ``macmini.tailf46ef8.ts.net``. Degrades quietly (never raises) when the
+    ``tailscale`` binary is absent, the call times out, or the output isn't
+    the JSON shape expected: this is an optional identity signal, one of
+    several :func:`resolve_local_machine` tries, not a hard dependency.
+    """
+    try:
+        result = subprocess.run(
+            ["tailscale", "status", "--self", "--json"],
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if result.returncode != 0 or not result.stdout:
+        return None
+    try:
+        data = json.loads(result.stdout)
+    except json.JSONDecodeError:
+        return None
+    self_info = data.get("Self") if isinstance(data, dict) else None
+    if not isinstance(self_info, dict):
+        return None
+    dns_name = self_info.get("DNSName") or self_info.get("HostName")
+    if not isinstance(dns_name, str) or not dns_name:
+        return None
+    return dns_name.rstrip(".").lower()
+
+
+# #3440: memo for :func:`_cached_tailscale_self_dns_name` — ``(monotonic
+# deadline | None, answer)``. A ``None`` deadline means "never expires".
+_TS_SELF_DNS_MEMO: tuple[float | None, str | None] | None = None
+
+# How long a FAILED probe is remembered. Deliberately short and finite: see
+# :func:`_cached_tailscale_self_dns_name`.
+TS_SELF_DNS_NEGATIVE_TTL = 60.0
+
+
+def reset_tailscale_self_dns_cache() -> None:
+    """Forget the memoized Tailscale self-identity.
+
+    Exported for tests (``tests/conftest.py`` resets it between tests, the
+    same shape as ``reset_resource_route_support``): a module-level memo
+    would otherwise leak one test's stubbed identity into the next.
+    """
+    global _TS_SELF_DNS_MEMO
+    _TS_SELF_DNS_MEMO = None
+
+
+def _cached_tailscale_self_dns_name(
+    *, now: float | None = None,
+) -> str | None:
+    """:func:`_tailscale_self_dns_name`, memoized — the accessor
+    :func:`resolve_local_machine` actually calls.
+
+    Why memoize at all: ``resolve_local_machine`` is called on a timer by
+    long-lived processes (``coord serve``'s reap ticks, every few seconds).
+    On a host that matches no machine by hostname — precisely the #3440 host,
+    and every thin client — the Tailscale tier is reached on EVERY call, so
+    an unmemoized probe is a ``tailscale`` subprocess (up to a 3s timeout)
+    every few seconds, forever.
+
+    Why a SUCCESS is cached forever but a FAILURE is not (#2096): a host's
+    Tailscale DNS name is a stable fact for the lifetime of a process, so
+    re-probing after a successful answer buys nothing. A failed probe is
+    *not* a fact about the host — it is a fact about the last 3 seconds
+    (``tailscaled`` not up yet, the daemon started at boot before the network
+    did). Caching that forever would turn a transient miss into a permanent,
+    uncontradictable "this host is not in the fleet" verdict for a daemon
+    that runs for days, which is the same class of bug as the one #3440 is
+    fixing. So a negative answer is retried after
+    ``TS_SELF_DNS_NEGATIVE_TTL`` seconds — bounded cost, self-healing.
+    """
+    global _TS_SELF_DNS_MEMO
+
+    now = time_module.monotonic() if now is None else now
+    memo = _TS_SELF_DNS_MEMO
+    if memo is not None:
+        expires_at, answer = memo
+        if expires_at is None or now < expires_at:
+            return answer
+
+    answer = _tailscale_self_dns_name()
+    _TS_SELF_DNS_MEMO = (
+        None if answer else now + TS_SELF_DNS_NEGATIVE_TTL,
+        answer,
+    )
+    return answer
+
+
+def resolve_local_machine(
+    config: "Config", *, env: "dict[str, str] | None" = None,
+) -> "Machine | None":
+    """The single answer to "which configured machine, if any, IS the host
+    this process is running on?" (#3440).
+
+    Every "is this local or remote" call site in the codebase must call
+    this instead of keeping a private ``socket.gethostname()`` comparison —
+    two independent implementations of the same question are a split-brain
+    waiting to happen (see #2085). Tried in order, first match wins:
+
+    1. Each machine's own ``local_hostnames:`` alias list (the operator's
+       escape hatch) against the OS short hostname — for hosts whose OS
+       hostname matches neither ``name`` nor ``host`` (macOS's default
+       ``Johns-Mac-mini``, observed on macmini).
+    2. The historical fallback: OS short hostname vs ``machine.name`` or
+       the first label of ``machine.host``. Tried BEFORE the Tailscale
+       probe below — deliberately: this comparison is pure and free, it
+       resolves the overwhelming majority of fleet machines (whose OS
+       hostname already agrees with `coordinator.yml`), and periodic
+       callers (`coord serve`'s reap ticks) run it every few seconds —
+       shelling out to `tailscale` that often, when a free comparison
+       already answers the question, is both wasteful and, in one
+       audited path, breaks a ToS no-unexpected-subprocess guardrail
+       (`tests/test_reap_merged_sessions.py`).
+    3. This host's Tailscale identity
+       (:func:`_cached_tailscale_self_dns_name`) against ``machine.host``'s
+       full DNS name, not just its first label — ``host:`` is set FROM the
+       Tailscale DNS name in this fleet, so this is the tier that actually
+       fixes #3440: it catches exactly the hosts step 2 cannot (an OS
+       hostname with nothing to do with the fleet name). Only reached when
+       steps 1–2 found nothing, AND memoized per process, so the subprocess
+       cost is paid once by the hosts that actually need it rather than on
+       every reap tick.
+    4. ``$COORD_LOCAL_MACHINE`` (or *env*'s override) naming a machine by
+       ``name`` exactly — the last-resort override for when none of the
+       above can match at all.
+
+    Returns ``None`` when nothing matches — callers must treat that as
+    "this host isn't a recognized machine in coordinator.yml", never
+    silently assume remote OR local.
+    """
+    local_hostname = _local_short_hostname()
+
+    for machine in config.machines:
+        # getattr, not a bare attribute read: some call sites pass
+        # duck-typed test fixtures predating this field rather than a real
+        # `coord.models.Machine` — treat "no attribute" the same as "empty
+        # list" (this field's own documented default) rather than raising.
+        aliases = {a.lower() for a in getattr(machine, "local_hostnames", None) or []}
+        if local_hostname in aliases:
+            return machine
+
+    for machine in config.machines:
+        if (
+            machine.name.lower() == local_hostname
+            or machine.host.split(".")[0].lower() == local_hostname
+        ):
+            return machine
+
+    ts_dns = _cached_tailscale_self_dns_name()
+    if ts_dns:
+        for machine in config.machines:
+            host = (machine.host or "").rstrip(".").lower()
+            if host and host == ts_dns:
+                return machine
+
+    if env is None:
+        env = os.environ
+    override = env.get("COORD_LOCAL_MACHINE")
+    if override:
+        for machine in config.machines:
+            if machine.name.lower() == override.lower():
+                return machine
+
+    return None
+
+
 def load(path: str | Path | None = None) -> Config:
     """Load and validate a coordinator.yml file.
 
@@ -3095,6 +3287,16 @@ def _parse_machines(raw: Any, repos: list[Repo]) -> list[Machine]:
             entry.get("quiet_hours"), machine_index=i, machine_name=name,
         )
 
+        # #3440: optional alias list of OS short hostnames that should be
+        # treated as "this machine" by `resolve_local_machine` — the
+        # operator's escape hatch for hosts whose OS hostname (e.g. macOS's
+        # `Johns-Mac-mini` default) matches neither `name` nor `host`.
+        local_hostnames = entry.get("local_hostnames", []) or []
+        if not isinstance(local_hostnames, list) or not all(
+            isinstance(h, str) for h in local_hostnames
+        ):
+            raise ConfigError(f"machines[{i}].local_hostnames must be a list of strings")
+
         # #3366: optional fact about which init system supervises this
         # host's `coord agent` — see `Machine.supervisor`'s docstring for
         # why it isn't inferred. Validated against the two names
@@ -3136,6 +3338,7 @@ def _parse_machines(raw: Any, repos: list[Repo]) -> list[Machine]:
                 quiet_hours=quiet_hours,
                 health_timeout=machine_health_timeout,
                 supervisor=machine_supervisor,
+                local_hostnames=local_hostnames,
             )
         )
     return machines

{code_coordinator-0.5.514 → code_coordinator-0.5.516}/coord/dashboard/server.py

@@ -3234,21 +3234,18 @@ def build_app(
             # Seeded roster — no tmux, no ssh fan-out in fixture mode.
             return JSONResponse(_fixture.sessions())
 
+        from coord.config import resolve_local_machine
         from coord.interactive import (
             TMUX_SESSION_PREFIX,
             TmuxHost,
-            _get_local_short_hostname,
             list_coord_tmux_sessions,
         )
 
         loop = asyncio.get_running_loop()
-        local_hn = _get_local_short_hostname()
+        _resolved_local = resolve_local_machine(config)
 
         def _is_local_machine(machine) -> bool:
-            return (
-                machine.name.lower() == local_hn
-                or machine.host.split(".")[0].lower() == local_hn
-            )
+            return _resolved_local is not None and _resolved_local.name == machine.name
 
         def _sweep_one(machine):
             is_local = _is_local_machine(machine)

{code_coordinator-0.5.514 → code_coordinator-0.5.516}/coord/dashboard/terminal.py

@@ -15,7 +15,6 @@ from __future__ import annotations
 
 import asyncio
 import os
-import socket
 import struct
 import subprocess
 from pathlib import Path
@@ -55,12 +54,6 @@ def resolve_web_token(flag_token: str | None = None) -> str | None:
     return None
 
 
-def _local_short_hostname() -> str:
-    """Same two-line idiom used inline in coord/interactive.py and
-    coord/commands/sessions.py -- there is no shared public helper for it."""
-    return socket.gethostname().split(".")[0].lower()
-
-
 def resolve_session_target(
     session_id: str, board: Board, config: Config
 ) -> tuple[str | None, str] | None:
@@ -93,11 +86,10 @@ def resolve_session_target(
     if machine is None:
         return None, session_name
 
-    local_hn = _local_short_hostname()
-    is_local = (
-        machine.name.lower() == local_hn
-        or machine.host.split(".")[0].lower() == local_hn
-    )
+    from coord.config import resolve_local_machine  # noqa: PLC0415
+
+    resolved_local = resolve_local_machine(config)
+    is_local = resolved_local is not None and resolved_local.name == machine.name
     return (None if is_local else machine.host), session_name