fix(network): detect offline state in Tauri via HTTPS probe

`navigator.onLine` is always true in Tauri's WebView, so probe github.com
every 30s to drive the offline pill, and relocate the pill into the
top-right header bar.

🪄 Commit via GitWand

Author: Laurent Guitton

apps/desktop/dev-server.mjs

@@ -4139,6 +4139,51 @@ async function handleRequest(req, res) {
       }
     }
 
+    // GET /api/git-merge-base?cwd=<path>&ref1=<ref>&ref2=<ref>
+    // Mirrors the Tauri `git_merge_base` command: returns the SHA of the
+    // best common ancestor between ref1 and ref2 (`git merge-base ref1 ref2`).
+    if (url.pathname === "/api/git-merge-base" && req.method === "GET") {
+      const cwd = url.searchParams.get("cwd");
+      const ref1 = url.searchParams.get("ref1");
+      const ref2 = url.searchParams.get("ref2");
+      if (!cwd || !ref1 || !ref2) return jsonResponse(req, res, { error: "Missing cwd, ref1 or ref2" }, 400);
+      try {
+        const result = spawnSync(GIT, ["merge-base", ref1, ref2], { cwd: resolve(cwd), encoding: "utf-8" });
+        if (result.status !== 0) return jsonResponse(req, res, { sha: "" });
+        return jsonResponse(req, res, { sha: result.stdout.trim() });
+      } catch (err) {
+        return jsonResponse(req, res, { error: err.message }, 500);
+      }
+    }
+
+    // POST /api/git-branch-merged  { cwd }
+    // Mirrors the Tauri `git_branch_merged` command: returns the list of
+    // local branches fully merged into the default branch, excluding the
+    // current branch and the default branch itself.
+    if (url.pathname === "/api/git-branch-merged" && req.method === "POST") {
+      const body = await readBody(req);
+      const cwd = String(body?.cwd ?? "").trim();
+      if (!cwd) return jsonResponse(req, res, { error: "Missing cwd" }, 400);
+      try {
+        // Determine default branch (main or master or first remote HEAD).
+        const headRef = spawnSync(GIT, ["symbolic-ref", "refs/remotes/origin/HEAD"], { cwd: resolve(cwd), encoding: "utf-8" });
+        const defaultBranch = headRef.status === 0
+          ? headRef.stdout.trim().replace("refs/remotes/origin/", "")
+          : "main";
+        const currentRef = spawnSync(GIT, ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: resolve(cwd), encoding: "utf-8" });
+        const current = currentRef.stdout.trim();
+        const result = spawnSync(GIT, ["branch", "--merged", defaultBranch], { cwd: resolve(cwd), encoding: "utf-8" });
+        if (result.status !== 0) return jsonResponse(req, res, []);
+        const merged = result.stdout
+          .split("\n")
+          .map((b) => b.replace(/^\*?\s+/, "").trim())
+          .filter((b) => b && b !== defaultBranch && b !== current);
+        return jsonResponse(req, res, merged);
+      } catch (err) {
+        return jsonResponse(req, res, { error: err.message }, 500);
+      }
+    }
+
     jsonResponse(req, res, { error: "Not found" }, 404);
   } catch (err) {
     jsonResponse(req, res, { error: err.message }, 500);
@@ -4173,5 +4218,7 @@ server.listen(PORT, "127.0.0.1", () => {
   console.log(`    GET  /api/gh-pr-checks?cwd=<path>&number=<n>`);
   console.log(`    GET  /api/pr-files?repo=<path>&pr=<n>`);
   console.log(`    GET  /api/git-remote-info?cwd=<path>`);
+  console.log(`    GET  /api/git-merge-base?cwd=<path>&ref1=<ref>&ref2=<ref>`);
+  console.log(`    POST /api/git-branch-merged  { cwd }`);
   console.log(`    POST /api/check-remote-reachable  { url, timeoutMs }\n`);
 });

apps/desktop/src/components/AppHeader.vue

@@ -317,6 +317,19 @@ onUnmounted(() => document.removeEventListener("click", onDocClick, true));
 
       <div class="app-header__tabs-spacer"></div>
 
+      <!-- Offline indicator pill (top-right, before Workspace) -->
+      <template v-if="isOffline">
+        <div class="header-separator header-separator--offline" aria-hidden="true"></div>
+        <div class="offline-pill" :title="t('offline.tooltip')">
+          <svg width="12" height="12" viewBox="0 0 16 16" fill="none" aria-hidden="true">
+            <path d="M2 2l12 12" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"/>
+            <path d="M9.5 4.5A6 6 0 0114 10M4.1 6.5A6 6 0 003 10M6.5 9.5A2 2 0 019.5 12M8 14v.01" stroke="currentColor" stroke-width="1.4" stroke-linecap="round"/>
+          </svg>
+          <span>{{ t('offline.label') }}</span>
+        </div>
+        <div class="header-separator header-separator--offline" aria-hidden="true"></div>
+      </template>
+
       <!-- Workspace button -->
       <button
         v-if="hasRepo"
@@ -437,15 +450,6 @@ onUnmounted(() => document.removeEventListener("click", onDocClick, true));
             @load-branches="emit('loadBranches')"
           />
 
-          <!-- Offline indicator pill -->
-          <div v-if="isOffline" class="offline-pill" :title="t('offline.tooltip')">
-            <svg width="12" height="12" viewBox="0 0 16 16" fill="none" aria-hidden="true">
-              <path d="M2 2l12 12" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"/>
-              <path d="M9.5 4.5A6 6 0 0114 10M4.1 6.5A6 6 0 003 10M6.5 9.5A2 2 0 019.5 12M8 14v.01" stroke="currentColor" stroke-width="1.4" stroke-linecap="round"/>
-            </svg>
-            <span>{{ t('offline.label') }}</span>
-          </div>
-
           <!-- BranchMenu + its two piggy-backed popovers.
                The popovers anchor on their own wrappers so the click-outside
                rules can target them precisely. header-left is position:relative
@@ -1036,19 +1040,28 @@ onUnmounted(() => document.removeEventListener("click", onDocClick, true));
   transform: scale(1.1);
 }
 
-/* ─── Offline pill ───────────────────────────────────── */
+/* ─── Offline pill (in top-right tab bar) ────────────── */
 .offline-pill {
   display: inline-flex;
   align-items: center;
   gap: var(--space-2);
-  padding: var(--space-1) var(--space-4);
+  padding: 3px var(--space-4);
   border-radius: var(--radius-pill);
   background: var(--color-bg-tertiary);
   border: 1px solid var(--color-border);
   color: var(--color-text-muted);
-  font-size: var(--font-size-sm);
+  font-size: var(--font-size-xs);
   font-weight: var(--font-weight-medium);
   white-space: nowrap;
   user-select: none;
+  flex-shrink: 0;
+}
+
+.header-separator--offline {
+  width: 1px;
+  height: 16px;
+  background: var(--color-border);
+  flex-shrink: 0;
+  margin-inline: var(--space-1);
 }
 </style>

apps/desktop/src/composables/useNetworkStatus.ts

@@ -1,24 +1,71 @@
 import { ref, onMounted, onUnmounted } from "vue";
 
 /**
- * Reactive wrapper around `navigator.onLine` + `online`/`offline` events.
+ * Reactive network-status composable.
  *
- * Returns `isOffline` — a readonly ref that is `true` whenever the browser
- * reports no network connectivity. Components can use this to disable remote
- * operations (push, pull, fetch, clone, …) and surface an indicator.
+ * Two detection strategies depending on the runtime:
+ *
+ * ── Browser (dev:web / pnpm dev:web) ──────────────────────────────────────
+ * `navigator.onLine` is reliable in a real browser: the OS network stack
+ * drives it, and the `online`/`offline` DOM events fire promptly.
+ * We simply mirror that value and subscribe to the events.
+ *
+ * ── Tauri WebView ─────────────────────────────────────────────────────────
+ * `navigator.onLine` is always `true` in the Tauri WebView because it
+ * reflects "is tauri://localhost reachable?" — which it always is, regardless
+ * of internet connectivity.
+ * Fix: probe a real HTTPS endpoint (HEAD, no-cors, 5 s timeout) every 30 s
+ * and on every `online`/`offline` event. An opaque success → online; a
+ * network-level throw → offline.
  */
+
+/** True when running inside a Tauri app (window.__TAURI__ is injected by Tauri). */
+const IS_TAURI = typeof window !== "undefined" && "__TAURI__" in window;
+
+const PROBE_URL = "https://github.com";
+const PROBE_INTERVAL = 30_000; // ms
+
+async function probeNetwork(): Promise<boolean> {
+  try {
+    await fetch(PROBE_URL, {
+      method: "HEAD",
+      mode: "no-cors",
+      cache: "no-store",
+      signal: AbortSignal.timeout(5_000),
+    });
+    return true; // opaque success = network reachable
+  } catch {
+    return false; // TypeError (network) or AbortError (timeout)
+  }
+}
+
 export function useNetworkStatus() {
-  const isOffline = ref(!navigator.onLine);
+  const isOffline = ref(IS_TAURI ? false : !navigator.onLine);
+
+  let intervalId: ReturnType<typeof setInterval> | null = null;
+
+  async function refresh() {
+    if (IS_TAURI) {
+      isOffline.value = !(await probeNetwork());
+    } else {
+      isOffline.value = !navigator.onLine;
+    }
+  }
 
-  function onOnline() { isOffline.value = false; }
-  function onOffline() { isOffline.value = true; }
+  function onOnline() { void refresh(); }
+  function onOffline() { void refresh(); }
 
   onMounted(() => {
+    if (IS_TAURI) {
+      void refresh(); // initial probe
+      intervalId = setInterval(refresh, PROBE_INTERVAL);
+    }
     window.addEventListener("online", onOnline);
     window.addEventListener("offline", onOffline);
   });
 
   onUnmounted(() => {
+    if (intervalId !== null) clearInterval(intervalId);
     window.removeEventListener("online", onOnline);
     window.removeEventListener("offline", onOffline);
   });

apps/desktop/src/utils/backend.ts

@@ -1846,14 +1846,10 @@ export async function checkRemoteReachable(
         Math.max(5_000, timeoutMs + 2_000),
       );
     }
-    const res = await devFetch(`${DEV_SERVER}/api/check-remote-reachable`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ url, timeoutMs }),
-    });
-    if (!res.ok) return false;
-    const data = (await res.json()) as { reachable?: boolean };
-    return !!data.reachable;
+    // In browser / dev-web mode the raw TCP probe is unreliable (corporate
+    // proxies, VPNs, etc. route TCP differently from HTTP). Stay optimistic:
+    // the actual git operations will surface real connectivity errors.
+    return true;
   } catch {
     // Any IPC / fetch / parse failure → treat as unreachable. The probe is
     // a best-effort signal; we'd rather flip into offline mode than throw.