chore(desktop): auto-restart host-service on bundle change in dev

[Kitenite]

Summary

• In NODE_ENV=development, watches the built host-service.js bundle and restarts running host-service instances via the coordinator when electron-vite rewrites it.
• New HostServiceCoordinator.enableDevReload(configProvider) debounces file events (250ms) and calls restartAll with the current auth token; no-ops when no instances are running or the user isn't signed in.
• Wired up from main/index.ts after discoverAll().

Not true HMR — workspace-scoped in-memory state (PTYs, watchers, chat streams) is torn down on each reload. Edit → rebuild → respawn is close enough for iterating on packages/host-service and src/main/host-service without restarting Electron.

Test plan

• bun dev in apps/desktop, sign in, open a workspace so a host-service instance is running.
• Edit a file under packages/host-service/src (e.g. add a console.log in serve.ts or a router); confirm electron-vite rebuilds and the main-process log shows [host-service] bundle changed, restarting running instances.
• Confirm the renderer reconnects and the host-service resumes serving tRPC within ~1s.
• Sign out / kill all instances and touch host-service.js; confirm no reload attempt happens (no-op path).
• Production build: verify the watcher does not run (gated on IS_DEV).

---

Summary by cubic

Auto-restart the host-service in development when the built host-service.js changes, waiting for the bundle to stabilize before restart. Enables a fast edit→reload loop without restarting Electron; dev-only and not HMR—host-service in-memory state resets on each reload.

• New Features
  • Added HostServiceCoordinator.enableDevReload(configProvider) to watch the built bundle, wait for a stable file size (~150ms, 5s deadline), debounce events (250ms), and restart running instances with the current auth token; avoids respawn errors during Rollup’s unlink+rewrite.
  • Wired up in main/index.ts after discoverAll() using loadToken() and mainEnv.NEXT_PUBLIC_API_URL.
  • No-op when no instances are running or the user is signed out.

^{Written for commit e6ae2c5. Summary will update on new commits.}

Summary by CodeRabbit

• Chores
  • Added development-only automatic reload for host-service bundles to restart background instances when builds change; includes safe debounce, teardown, and error handling.
  • Startup now supports loading a development auth token and dev environment API URL used by the dev reload flow.

[coderabbitai]

📝 Walkthrough

Walkthrough

Adds a development-only hot-reload feature: Electron main loads an auth token and API URL and enables a host-service coordinator dev watcher that detects host-service bundle changes, debounces and waits for stabilization, fetches updated spawn config, and restarts running host-service instances.

Changes

Cohort / File(s)	Summary
Main startup apps/desktop/src/main/index.ts	Conditionally enable dev reload on startup (dev-only). Asynchronously loads token via loadToken() and passes { authToken, cloudApiUrl: mainEnv.NEXT_PUBLIC_API_URL } into the host service coordinator.
Host service coordinator apps/desktop/src/main/lib/host-service-coordinator.ts	Adds public enableDevReload(configProvider: () => Promise<SpawnConfig | null>) to watch the host-service bundle, debounce change events, wait for bundle size stabilization, avoid overlapping reloads, skip when no orgs, fetch updated SpawnConfig, call restartAll(config), expose teardown function, and add watcher/error handling.

Sequence Diagram(s)

sequenceDiagram
    participant Main as Electron Main
    participant Auth as Auth Loader
    participant Env as mainEnv
    participant HSC as HostServiceCoordinator
    participant FS as File System
    participant Config as Config Provider

    Main->>Auth: call loadToken()
    Auth-->>Main: token | null
    Main->>Env: read NEXT_PUBLIC_API_URL
    Main->>HSC: enableDevReload(configProvider, {authToken, cloudApiUrl})
    HSC->>FS: fs.watch(bundleDir)
    Note over FS: watching host-service bundle
    FS->>HSC: change event
    HSC->>HSC: debounce + wait for stable size
    HSC->>Config: call configProvider()
    Config-->>HSC: SpawnConfig | null
    HSC->>HSC: restartAll(SpawnConfig)
    HSC-->>Main: teardown function

Loading

Estimated code review effort

🎯 4 (Complex) | ⏱️ ~45 minutes

Poem

🐇 I nibble bytes and watch the tree,

when bundles change, I spring with glee.
Token in paw, I call the tune,
Restart, refresh — a dev-time boon.
Hoppity hop, dev cycles resume.

🚥 Pre-merge checks | ✅ 3

✅ Passed checks (3 passed)

Check name	Status	Explanation
Title check	✅ Passed	The title clearly and concisely summarizes the main change: auto-restarting host-service on bundle changes in development mode.
Description check	✅ Passed	The description includes a detailed summary, test plan with checkboxes, and additional context; it largely covers the template structure despite being more comprehensive than the template requires.
Docstring Coverage	✅ Passed	No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

✨ Finishing Touches

📝 Generate docstrings

• Create stacked PR
• Commit on current branch

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Commit unit tests in branch faint-coast

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[greptile-apps]

Greptile Summary

This PR adds a dev-only hot-rebuild loop for the host-service in the desktop Electron app. In NODE_ENV=development, HostServiceCoordinator.enableDevReload(configProvider) attaches an fs.watch listener to the directory containing the built host-service.js bundle. When electron-vite rewrites the file, a 250 ms debounce fires and calls restartAll using the current auth token — no-oping when no instances are running or the user is signed out. The watcher is gated strictly on IS_DEV in main/index.ts, so production builds are unaffected.

• enableDevReload is self-contained: idempotency guard, debounce, reloading mutex, and a returned cleanup closure all look correct for the intended use case.
• The returned cleanup function (closes the FSWatcher and clears a pending debounce) is discarded in index.ts — it should be stored and wired to before-quit so pending timers are cancelled on exit.
• The reloading flag is raised after await configProvider(), leaving a narrow window where two debounce windows that overlap during a slow loadToken() call could both proceed into restartAll. Moving reloading = true to before the first await closes the gap.
• fs.watch on the directory (not the file) correctly filters on filename; when the OS supplies null for filename (possible on some Linux configurations), the guard falls through and trigger is called for any directory event — acceptable over-firing for a dev tool.
• bun.lock update is incidental.

Confidence Score: 5/5

Safe to merge — dev-only feature with correct production gating; both findings are non-blocking P2 style suggestions.

The feature is gated strictly on IS_DEV and cannot affect production builds. The two issues found (discarded cleanup handle and reloading flag set post-await) are both edge cases with negligible practical impact in a dev workflow. The core logic — debounce, idempotency guard, active-instance check, null-config bail-out — is sound.

No files require special attention; both comments are on host-service-coordinator.ts and index.ts and are non-blocking.

Important Files Changed

Filename	Overview
apps/desktop/src/main/lib/host-service-coordinator.ts	Adds enableDevReload: watches the host-service bundle directory with fs.watch, debounces events at 250 ms, and calls restartAll when the file changes. Guards (reloading flag, active-instance check, null-config bail-out) are correct; minor issue is that reloading is set after the first await rather than before it.
apps/desktop/src/main/index.ts	Wires enableDevReload into the app startup after discoverAll(), correctly gated on IS_DEV. The cleanup function returned by enableDevReload is discarded rather than bound to before-quit.
bun.lock	Lockfile updated automatically; no manual changes, no new dependencies of concern.

Sequence Diagram

sequenceDiagram
    participant EV as electron-vite
    participant FS as fs.watch (scriptDir)
    participant TR as trigger() / debounce
    participant CP as configProvider (loadToken)
    participant HC as HostServiceCoordinator
    participant HS as host-service process(es)

    EV->>FS: rewrites host-service.js
    FS->>TR: onChange event (filename=host-service.js)
    TR->>TR: clearTimeout(prev debounce)
    TR->>TR: setTimeout 250ms
    Note over TR: debounce window
    TR->>TR: debounce fires
    TR->>HC: getActiveOrganizationIds()
    alt no running instances
        HC-->>TR: [] → no-op
    else instances running
        HC-->>TR: [orgId, ...]
        TR->>CP: configProvider()
        CP->>CP: loadToken()
        alt user not signed in
            CP-->>TR: null → no-op
        else signed in
            CP-->>TR: { authToken, cloudApiUrl }
            TR->>HC: restartAll(config)
            HC->>HS: stop(orgId) → SIGTERM
            HC->>HS: spawn(orgId, config)
            HS-->>HC: healthy (port, secret)
            HC-->>TR: done
        end
    end

Loading

_{Reviews (1): Last reviewed commit: "chore(desktop): auto-restart host-servic..." | Re-trigger Greptile}

[cubic-dev-ai]

1 issue found across 3 files

Prompt for AI agents (unresolved issues)

Check if these issues are valid — if so, understand the root cause of each and fix them. If appropriate, use sub-agents to investigate and fix each issue separately.


<file name="apps/desktop/src/main/lib/host-service-coordinator.ts">

<violation number="1" location="apps/desktop/src/main/lib/host-service-coordinator.ts:252">
P3: Race condition: `reloading = true` is set after the `await configProvider()` gap, so two invocations can both pass the `if (reloading) return` check before either sets the flag. Move `reloading = true` before the first `await` to actually guard against concurrent restarts.</violation>
</file>

_{Reply with feedback, questions, or to request a fix. Tag @cubic-dev-ai to re-run a review.}

[github-actions]

🧹 Preview Cleanup Complete

The following preview resources have been cleaned up:

• ✅ Neon database branch
• ✅ Electric Fly.io app

Thank you for your contribution! 🎉

[coderabbitai]

🧹 Nitpick comments (1)

apps/desktop/src/main/lib/host-service-coordinator.ts (1)

234-237: Repeated calls return a no-op teardown.

If enableDevReload is called multiple times, subsequent calls return () => {} instead of the actual teardown function. This means only the first caller can properly clean up the watcher. If this method might be called from multiple places or re-invoked, consider returning the existing teardown capability or storing it for retrieval.

💡 Option: return a shared teardown or log a warning

 	enableDevReload(
 		configProvider: () => Promise<SpawnConfig | null>,
 	): () => void {
-		if (this.devReloadWatcher) return () => {};
+		if (this.devReloadWatcher) {
+			console.warn("[host-service] dev reload already enabled");
+			return () => {};
+		}

Alternatively, store the teardown function as a field and return it on repeated calls.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@apps/desktop/src/main/lib/host-service-coordinator.ts` around lines 234 -
237, enableDevReload currently returns a no-op when called a second time because
it only checks this.devReloadWatcher and returns () => {} instead of the actual
teardown, so change the logic to return the existing teardown function when a
watcher already exists: capture and store the real teardown (e.g., assign to a
field like this.devReloadTeardown or attach it to this.devReloadWatcher) when
creating the watcher inside enableDevReload and on subsequent calls return that
stored teardown instead of an empty closure; ensure the teardown clears both the
watcher and the stored teardown field so repeated enable/teardown cycles remain
consistent.

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Nitpick comments:
In `@apps/desktop/src/main/lib/host-service-coordinator.ts`:
- Around line 234-237: enableDevReload currently returns a no-op when called a
second time because it only checks this.devReloadWatcher and returns () => {}
instead of the actual teardown, so change the logic to return the existing
teardown function when a watcher already exists: capture and store the real
teardown (e.g., assign to a field like this.devReloadTeardown or attach it to
this.devReloadWatcher) when creating the watcher inside enableDevReload and on
subsequent calls return that stored teardown instead of an empty closure; ensure
the teardown clears both the watcher and the stored teardown field so repeated
enable/teardown cycles remain consistent.

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Run ID: 78349523-938e-4bc7-9df6-114b7d828e3e

📥 Commits

Reviewing files that changed from the base of the PR and between 66e6aae and e6ae2c5.

📒 Files selected for processing (1)

• apps/desktop/src/main/lib/host-service-coordinator.ts