Struct WorktreesService 

pub struct WorktreesService { /* private fields */ }

Hosts the cross-window WorktreesRegistry as a DaemonService.

Implementations

impl WorktreesService

pub fn new() -> Self

Creates the service with an empty registry. Cheap — no I/O and no task; the daemon calls start_menu_refresh to begin off-thread menu caching, while tests use the bare service (menu computed inline on demand).

pub fn load_polling_prefs(&self, path: PathBuf)

Seeds the per-repo PR-poll enable set from the persisted 0600 prefs file and remembers path so later set-polling changes persist back to it (#1376). Called once by the daemon at startup, before any window subscribes — so seed_polling needs no bump. Best-effort throughout: a missing file is the first-run default (no repos enabled), and a corrupt/unreadable one is logged and treated as empty rather than wedging the service — the user simply re-enables. The path is stored regardless, so the next change rewrites a clean file.

pub fn load_pr_cache(&self, path: PathBuf)

Seeds the resolved PR-badge cache from the persisted 0600 file and remembers path so each poll persists back to it (#1389, fix 4). Called once by the daemon at startup, before any window subscribes and before the poller spawns, so restored badges render on the first tree snapshot and the poller can skip its immediate re-poll for verdicts still fresh.

Best-effort throughout (the load_polling_prefs contract): a missing file is the cold-start default, and a corrupt/unreadable one is logged and treated as empty — the poller simply re-resolves. The path is stored regardless, so the next poll rewrites a clean file. Restores both the badges (into pr_cache) and the PrWarmStart the poller reads at spawn.

pub fn rate_limit_cache(&self) -> Arc<RateLimitCache>

A handle to the GitHub rate-limit snapshot cache (#1375), so the daemon can share it with the ServiceRegistry for the built-in status op to read.

pub fn start_menu_refresh(&self)

Starts the background task that recomputes the tray menu snapshot every [menu_refresh_interval] off the main thread — git enrichment is blocking disk I/O — and stores it in menu_cache, so the macOS tray’s menu() serves a cache instead of running git on the GUI event loop. Idempotent, and a no-op outside a tokio runtime (mirroring the Snowflake keep-alive heartbeat), so unit tests that build a bare service keep computing the menu inline.

pub fn start_pr_poller(&self)

Starts the background task that keeps PR check badges fresh (#1337).

This is the half of the badge nothing else can do. Badges used to be resolved extension-side on repo-expand, so they were recomputed only when a repo node’s children were rebuilt — and the streamed snapshot carries worktree topology, not CI. While CI ran and no window opened or closed, nothing re-asked GitHub and a badge stayed wrong indefinitely.

The loop resolves every (repo, branch) pair in one gh api graphql call (cost 1, independent of repo/worktree/window count), writes the cache the tree snapshot reads, and bumps the registry’s change-notify only when a verdict actually moved — so the server’s diff pushes to every open window exactly when CI state changes, and never otherwise.

Cadence adapts: [pr_poll_interval] (~10 s) while a badge is pending and fresh, escalating to [PENDING_MAX_INTERVAL] once a pending phase runs long (#1389, fix 5) and doubling to [MAX_PR_POLL_INTERVAL] once everything is terminal; it polls nothing at all while no window is registered.

It spends a gh call only when the watch set grows — a target added or an upstream pushed (#1389, fixes 1/3) — or the backoff elapses; a pure removal (window close, VS Code/daemon shutdown, TTL reap, lease lapse) never fetches. A change-notify storm is debounced ([pr_debounce_interval], #1389 fix 2) into one fetch, restored badges survive a restart (#1389 fix 4), and the cadence is capped when the shared GitHub budget is strained (#1389 fix 6).

Idempotent, and a no-op outside a tokio runtime (mirroring start_menu_refresh and the Snowflake keep-alive heartbeat), so unit tests build a bare service that never spawns gh.

pub fn start_rate_limit_poller(&self)

Starts the background task that keeps the GitHub API rate-limit reading fresh (#1375).

The daemon’s PR-badge poller shells out to gh, spending the same GitHub budget as every other tool sharing the user’s token; when that drains, gh rate-limits machine-wide with no warning until commands start failing. This loop polls gh api rate_limit — an endpoint GitHub documents (and this project verified) as exempt, spending nothing against any budget — so daemon status, the JSON payload, and the tray can show the used-percentage trend and warn before exhaustion, at zero cost to the budget watched.

A plain fixed cadence ([rate_limit_poll_interval], ~60 s): no adaptive backoff and no window-gating, because the endpoint is free and a current reading is wanted whenever an operator checks status. Idempotent, and a no-op outside a tokio runtime (mirroring start_pr_poller and start_menu_refresh), so unit tests build a bare service that never spawns gh.

Trait Implementations

impl DaemonService for WorktreesService

fn name(&self) -> &'static str

Stable identifier used to route control-socket envelopes to this service (the envelope’s service field) and to label its status/menu.

fn handle<'life0, 'life1, 'async_trait>( &'life0 self, op: &'life1 str, payload: Value, ) -> Pin<Box<dyn Future<Output = Result<Value>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handles an operation routed to this service, returning a JSON payload.

fn subscribe( &self, op: &str, _payload: &Value, ) -> Option<Box<dyn ServiceStream>>

Opens a push subscription for a streaming op, or returns None when op is not one this service streams (the default for every service).

fn menu(&self) -> MenuSnapshot

Cheap snapshot of the service’s tray submenu, polled by the menu-bar shell. Must not block.

fn menu_action<'life0, 'life1, 'async_trait>( &'life0 self, action_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Performs a tray menu action previously surfaced by menu, identified by its MenuAction::id.

fn status<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ServiceStatus> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Structured status for daemon status aggregation.

fn shutdown<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Gracefully stops the service, draining in-flight work. Called once on daemon shutdown.

impl Default for WorktreesService

fn default() -> Self

Returns the “default value” for a type.