supbuddy 3.0.9 → 3.0.11

package/dist/daemon/worker.cjs

@@ -37777,11 +37777,14 @@ function projectsNeedingVmMigration(projects) {
   return projects.filter((p) => p.isolation === "vm");
 }
 const ALL_SCOPE_KEYS = Object.keys(McpScopesSchema.shape);
-function dnsResolverRepairNeeded(resolver) {
-  if (resolver.in_sync !== false) return false;
-  const hasMissing = Array.isArray(resolver.missing) && resolver.missing.length > 0;
-  const hasExtra = Array.isArray(resolver.extra) && resolver.extra.length > 0;
-  return hasMissing || hasExtra;
+function dnsResolverRepairNeeded(resolver, os2) {
+  if (resolver.in_sync === false) {
+    const hasMissing = Array.isArray(resolver.missing) && resolver.missing.length > 0;
+    const hasExtra = Array.isArray(resolver.extra) && resolver.extra.length > 0;
+    if (hasMissing || hasExtra) return true;
+  }
+  if (resolver.in_sync === true && os2?.serverUp && os2.loaded === false) return true;
+  return false;
 }
 const readTools = {
   list_pending_vm_migrations: async () => {
@@ -37810,9 +37813,9 @@ const readTools = {
   },
   get_settings: async () => useStore.getState().settings,
   get_health: async () => {
-    const { auditResolverState: auditResolverState2, probeLocalDnsServer: probeLocalDnsServer2, probeProxyReachability: probeProxyReachability2 } = await __vitePreload(async () => {
-      const { auditResolverState: auditResolverState3, probeLocalDnsServer: probeLocalDnsServer3, probeProxyReachability: probeProxyReachability3 } = await Promise.resolve().then(() => dnsPlatform);
-      return { auditResolverState: auditResolverState3, probeLocalDnsServer: probeLocalDnsServer3, probeProxyReachability: probeProxyReachability3 };
+    const { auditResolverState: auditResolverState2, probeLocalDnsServer: probeLocalDnsServer2, probeProxyReachability: probeProxyReachability2, probeOsResolverLoaded: probeOsResolverLoaded2 } = await __vitePreload(async () => {
+      const { auditResolverState: auditResolverState3, probeLocalDnsServer: probeLocalDnsServer3, probeProxyReachability: probeProxyReachability3, probeOsResolverLoaded: probeOsResolverLoaded3 } = await Promise.resolve().then(() => dnsPlatform);
+      return { auditResolverState: auditResolverState3, probeLocalDnsServer: probeLocalDnsServer3, probeProxyReachability: probeProxyReachability3, probeOsResolverLoaded: probeOsResolverLoaded3 };
     }, false ? __VITE_PRELOAD__ : void 0);
     const { getLanInterfaces: getLanInterfaces2 } = await __vitePreload(async () => {
       const { getLanInterfaces: getLanInterfaces3 } = await Promise.resolve().then(() => mdnsResponder);
@@ -37823,7 +37826,7 @@ const readTools = {
     const ownIps = getLanInterfaces2().map((i2) => i2.address);
     const liveness = await probeProxyLiveness();
     const proxyStatus = deriveReportedStatus(s.proxyState.status, liveness, { restartInFlight: isCaddyRestartInFlight() });
-    const [resolver, probe, reachability] = await Promise.all([
+    const [resolver, probe, reachability, osResolver] = await Promise.all([
       auditResolverState2().catch((e) => ({ in_sync: null, missing: [], extra: [], expected: [], error: e.message })),
       s.dnsState.status === "running" ? probeLocalDnsServer2(dnsPort).catch((e) => ({ ok: false, error: e.message })) : Promise.resolve({ ok: false, error: `dns server not running (status=${s.dnsState.status})` }),
       // Gate the reachability probe on a LIVE liveness check, not the tracked status —
@@ -37833,9 +37836,17 @@ const readTools = {
         resolved: [],
         reachable: [],
         error: e.message
-      })) : Promise.resolve({ ok: false, resolved: [], reachable: [], error: `caddy not alive (status=${proxyStatus})` })
+      })) : Promise.resolve({ ok: false, resolved: [], reachable: [], error: `caddy not alive (status=${proxyStatus})` }),
+      // Did the OS actually LOAD /etc/resolver? The file audit above only checks
+      // presence on disk — on Sonoma+ the files can be correct yet unloaded, so a
+      // managed domain won't resolve while `in_sync` reports healthy. getaddrinfo
+      // is the direct test of the loaded state.
+      probeOsResolverLoaded2().catch((e) => ({ loaded: null, error: e.message }))
     ]);
-    const resolverRepairNeeded = dnsResolverRepairNeeded(resolver);
+    const resolverRepairNeeded = dnsResolverRepairNeeded(resolver, {
+      loaded: osResolver.loaded,
+      serverUp: probe.ok === true
+    });
     return {
       worker: { running: true, uptime_ms: process.uptime() * 1e3 },
       mcp_server: s.mcpServerState,
@@ -37847,7 +37858,17 @@ const readTools = {
       },
       dns: {
         server: { ...s.dnsState, probe },
-        resolver: { ...resolver, repairNeeded: resolverRepairNeeded },
+        resolver: {
+          ...resolver,
+          repairNeeded: resolverRepairNeeded,
+          // Whether the OS actually loaded the resolver files (getaddrinfo of a
+          // managed domain). Distinct from `in_sync` (files on disk): on Sonoma+
+          // `in_sync` can be true while `os_loaded` is false — a privileged reload
+          // (restart_proxy) heals it.
+          os_loaded: osResolver.loaded,
+          ...osResolver.domain ? { os_probe_domain: osResolver.domain } : {},
+          ...osResolver.error ? { os_probe_error: osResolver.error } : {}
+        },
         reachability
       }
     };
@@ -48250,7 +48271,7 @@ port ${port}
     commands.push(`cp "${tmpPath}" "${filePath}"`);
   }
   const writeChain = commands.join(" && ");
-  const flush = "{ dscacheutil -flushcache; killall -HUP mDNSResponder 2>/dev/null; true; }";
+  const flush = "{ dscacheutil -flushcache; launchctl kickstart -k system/com.apple.mDNSResponder.reloaded 2>/dev/null || launchctl kickstart -k system/com.apple.mDNSResponder 2>/dev/null || killall -HUP mDNSResponder 2>/dev/null; true; }";
   return { command: `${writeChain} && ${flush}`, tmpFiles };
 }
 async function buildMacOsCleanupCommand() {
@@ -48460,6 +48481,23 @@ async function probeLocalDnsServer(port, timeoutMs = 1e3) {
     });
   });
 }
+async function probeOsResolverLoaded(timeoutMs = 1500) {
+  const store2 = useStore.getState();
+  const target = store2.mappings.find((m) => m.enabled)?.domain;
+  if (!target) return { loaded: null };
+  try {
+    const addrs = await Promise.race([
+      dns$2.lookup(target, { all: true }),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(Object.assign(new Error("getaddrinfo timeout"), { code: "ETIMEDOUT" })), timeoutMs)
+      )
+    ]);
+    return { loaded: Array.isArray(addrs) && addrs.length > 0, domain: target };
+  } catch (err) {
+    const e = err;
+    return { loaded: false, domain: target, error: e.code || e.message };
+  }
+}
 function resolveReachabilityHint(rawHint, lanSharing) {
   if (rawHint === "mdns_hijack" && !lanSharing) return "resolved_but_unreachable";
   return rawHint;
@@ -48572,6 +48610,7 @@ const dnsPlatform = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineP
   buildPlatformDnsCommand,
   getManagedDomainSuffixes,
   probeLocalDnsServer,
+  probeOsResolverLoaded,
   probeProxyReachability,
   resolveReachabilityHint
 }, Symbol.toStringTag, { value: "Module" }));
@@ -50019,7 +50058,7 @@ async function checkProxyReachabilityAndSurface() {
   const hintMessage = {
     mdns_hijack: `Browser DNS for ${result.domain} returns ${result.resolved.join(", ")} (your own LAN IP) but Caddy isn't reachable on port ${result.port}. This usually means LAN sharing is publishing the name via Bonjour and pf rules need a re-apply — toggle the proxy off/on, or disable LAN sharing.`,
     foreign_owner: `Another device on your LAN is responding for ${result.domain} (${result.resolved.join(", ")}) — Bonjour/mDNS race for the .local namespace. Switch this project's TLD to .test in Settings, or take the other device offline.`,
-    no_resolution: `The OS resolver couldn't resolve ${result.domain}. Check that /etc/resolver/<project-domain> exists (visible in get_health → dns.resolver) and that the DNS server on :${store2.dnsState.port} is answering.`,
+    no_resolution: `The OS resolver couldn't resolve ${result.domain}. The resolver files and DNS server on :${store2.dnsState.port} may be fine — on macOS Sonoma+ the OS often just hasn't loaded /etc/resolver yet. Click RETRY (or restart the proxy) to rewrite the resolver files and reload the OS DNS cache. If it persists, run get_health → dns.resolver to check for missing files.`,
     resolved_but_unreachable: `${result.domain} resolves to ${result.resolved.join(", ")} but TCP connect to port ${result.port} fails. Likely a port-forwarding rule is missing for that IP — toggle the proxy off/on.`
   };
   const effectiveHint = resolveReachabilityHint2(result.hint, store2.settings.lanSharing);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supbuddy",
-  "version": "3.0.9",
+  "version": "3.0.11",
   "description": "Run multiple Supabase projects at once on custom local domains with HTTPS. A headless CLI and daemon (proxy, DNS, Supabase/Compose lifecycle, MCP) for macOS and Linux.",
   "keywords": [
     "supabase",