@iann29/synapse 1.8.9 → 1.8.10

package/lib/commands/https-setup.js

@@ -240,6 +240,34 @@ Examples:
       process.exitCode = 1;
       return;
     }
+
+    // v1.8.10: post-execute verification. Even after every step
+    // reports ✓ the actual end-state can be wrong — most commonly on
+    // Windows where the DNS Client cache holds a negative response
+    // even after the hosts file is updated. Re-scan and verify the
+    // domain ACTUALLY resolves to 127.0.0.1 (when we wrote hosts).
+    // If it doesn't, surface a yellow warning with a concrete
+    // remediation instead of pretending the setup is healthy.
+    const wroteHosts = results.some(
+      (r) => r.id === "hosts" && r.kind === "ok",
+    );
+    const verifyOk = after.resolution.resolvesToLoopback;
+    if (wroteHosts && !verifyOk && !skipHosts) {
+      summary.verifyResolution = false;
+      summary.verifyHint =
+        detection.platform.id === "windows"
+          ? "Windows DNS Client cache is still serving stale NXDOMAIN for this domain. Run `ipconfig /flushdns` from an Administrator PowerShell, then retry `npm run dev:https`. If it still fails, restart your machine."
+          : "Hosts file was written but the OS resolver still doesn't return 127.0.0.1. Try restarting nscd / systemd-resolved if you use one, or open a new shell.";
+      if (!ctx.out.json) {
+        ctx.out.stdout.write("\n");
+        ctx.out.warn(
+          `${domain} doesn't resolve to 127.0.0.1 yet — ${summary.verifyHint}`,
+        );
+      }
+    } else if (wroteHosts && verifyOk) {
+      summary.verifyResolution = true;
+    }
+
     ctx.out.stdout.write(
       `${colors.green("✓")} ${colors.bold(`HTTPS ready for ${domain}`)}\n`,
     );

package/lib/https/hosts.js

@@ -178,6 +178,26 @@ function readHosts(hostsPath) {
   }
 }
 
+// Best-effort DNS cache flush. On Windows the DNS Client (Dnscache)
+// service caches lookups separately from the hosts file — editing
+// /etc/hosts on Windows does NOT invalidate the cache, so `next dev`
+// and Node's dns.lookup() can both return ENOTFOUND despite the
+// entry being written correctly. This bit Matheus's Windows machine
+// in real-world testing (v1.8.10 bug report).
+//
+// `ipconfig /flushdns` is safe to call without admin elevation on
+// every Windows version since at least Windows 7, but we never let a
+// failure here block the wider flow — it's a hint, not a guarantee.
+function flushDnsCacheIfWindows({ execImpl = execFileSync, platform = process.platform } = {}) {
+  if (platform !== "win32") return { ran: false, reason: "non-windows platform" };
+  try {
+    execImpl("ipconfig", ["/flushdns"], { stdio: "ignore", timeout: 5000 });
+    return { ran: true };
+  } catch (err) {
+    return { ran: false, reason: err.message };
+  }
+}
+
 // Writes content to the hosts file. Three strategies are tried in
 // order based on the platform + the `elevation` knob:
 //
@@ -191,6 +211,13 @@ function readHosts(hostsPath) {
 //   - "never": only try direct write; error if it fails
 //   - "always": skip the direct write attempt
 //
+// On Windows we additionally:
+//   - Normalise line endings to CRLF (the Windows hosts file
+//     traditionally uses CRLF; some Windows components are tolerant
+//     of LF but defensive normalisation costs nothing)
+//   - Run `ipconfig /flushdns` after a successful write so the
+//     DNS Client cache picks up the new entry immediately
+//
 // `writeImpl` is injected for tests.
 function writeHosts(hostsPath, content, {
   elevation = "auto",
@@ -198,11 +225,15 @@ function writeHosts(hostsPath, content, {
   execImpl = execFileSync,
   platform = process.platform,
 } = {}) {
+  const onDiskContent =
+    platform === "win32" ? content.replace(/\r?\n/g, "\r\n") : content;
+
   // Try direct write first (fast path).
+  let result;
   if (elevation !== "always") {
     try {
-      writeImpl(hostsPath, content);
-      return { method: "direct", elevated: false };
+      writeImpl(hostsPath, onDiskContent);
+      result = { method: "direct", elevated: false };
     } catch (err) {
       if (elevation === "never") {
         throw new HostsError(
@@ -214,10 +245,25 @@ function writeHosts(hostsPath, content, {
     }
   }
 
+  if (!result) {
+    if (platform === "win32") {
+      result = writeHostsViaRunAs(hostsPath, onDiskContent, { execImpl });
+    } else {
+      result = writeHostsViaSudo(hostsPath, onDiskContent, { execImpl });
+    }
+  }
+
+  // Post-write DNS cache flush (best-effort, Windows only). The
+  // elevated runas path ALREADY flushes inside its PowerShell script
+  // — see writeHostsViaRunAs. Calling here covers the direct-write
+  // case (operator already in an elevated shell). Doubling up is
+  // harmless: a second flush is a no-op.
   if (platform === "win32") {
-    return writeHostsViaRunAs(hostsPath, content, { execImpl });
+    const flush = flushDnsCacheIfWindows({ execImpl, platform });
+    result.dnsFlushed = flush.ran;
+    if (!flush.ran) result.dnsFlushReason = flush.reason;
   }
-  return writeHostsViaSudo(hostsPath, content, { execImpl });
+  return result;
 }
 
 // Linux/macOS elevated write. We pipe the new content into `sudo
@@ -269,12 +315,18 @@ function writeHostsViaRunAs(hostsPath, content, { execImpl = execFileSync } = {}
   const tmpFile = path.join(os.tmpdir(), `synapse-hosts-${Date.now()}.txt`);
   fs.writeFileSync(tmpFile, content);
   const backupPath = `${hostsPath}.synapse-bak.${Date.now()}`;
-  // PowerShell script (single-line, double-quote-friendly):
-  //   Copy-Item <hosts> <backup>; Move-Item -Force <tmp> <hosts>
+  // PowerShell script — runs ELEVATED via Start-Process RunAs below.
+  //   1. Copy current hosts to backup
+  //   2. Move new content over hosts
+  //   3. ipconfig /flushdns (v1.8.10): WITHOUT this the Windows DNS
+  //      Client cache keeps returning NXDOMAIN for the freshly-added
+  //      entry, breaking `next dev --hostname dev.foo.com` with
+  //      ENOTFOUND despite the hosts file being correct.
   const script = [
     `try {`,
     `  Copy-Item -LiteralPath '${hostsPath}' -Destination '${backupPath}' -ErrorAction Stop;`,
     `  Move-Item -LiteralPath '${tmpFile}' -Destination '${hostsPath}' -Force -ErrorAction Stop;`,
+    `  & ipconfig /flushdns | Out-Null;`,
     `  exit 0`,
     `} catch {`,
     `  Write-Error $_.Exception.Message;`,
@@ -345,6 +397,7 @@ module.exports = {
   MANAGED_BLOCK_START,
   MANAGED_BLOCK_END,
   hostsPathForOS,
+  flushDnsCacheIfWindows,
   planAddEntry,
   planRemoveEntry,
   readHosts,

package/lib/https/planner.js

@@ -182,6 +182,16 @@ function plan(detection, {
   }
 
   // ---- Step: hosts file ----------------------------------------------
+  // Decision tree:
+  //   1. --skip-hosts                            → skip
+  //   2. Resolves via public DNS                  → skip (any machine works)
+  //   3. Hosts has entry + resolution works       → skip (idempotent)
+  //   4. Hosts has entry + resolution still fails → exec ("DNS cache
+  //      stale" fix — re-writing triggers ipconfig /flushdns on Windows).
+  //      This is the v1.8.10 fix for the bug Matheus hit: hosts file
+  //      had the entry but Windows DNS Client kept returning ENOTFOUND.
+  //   5. No entry                                 → exec (write + flush)
+  const hostsHasEntry = detection.hosts.matches.some((m) => m.address === "127.0.0.1");
   if (skipHosts) {
     steps.push({
       id: "hosts",
@@ -202,13 +212,26 @@ function plan(detection, {
       skipReason:
         "no hosts edit needed — DNS A record points at loopback (any machine on any OS resolves correctly)",
     });
-  } else if (detection.hosts.matches.some((m) => m.address === "127.0.0.1")) {
+  } else if (hostsHasEntry && detection.resolution.resolvesToLoopback) {
     steps.push({
       id: "hosts",
       title: "Hosts file entry",
       kind: "skip",
-      reason: `${detection.hosts.path} already maps ${detection.domain} to 127.0.0.1`,
-      skipReason: "entry present",
+      reason: `${detection.hosts.path} already maps ${detection.domain} to 127.0.0.1 and resolution works`,
+      skipReason: "entry present + DNS cache fresh",
+    });
+  } else if (hostsHasEntry && !detection.resolution.resolvesToLoopback) {
+    steps.push({
+      id: "hosts",
+      title: `Refresh DNS cache for ${detection.domain}`,
+      kind: "exec",
+      reason:
+        detection.platform.id === "windows"
+          ? `${detection.hosts.path} has the entry but Windows DNS cache is stale — re-writing to trigger \`ipconfig /flushdns\``
+          : `${detection.hosts.path} has the entry but resolution still fails — re-writing to force a refresh`,
+      async run() {
+        return hostsMod.addEntry(detection.hosts.path, detection.domain);
+      },
     });
   } else {
     const needsElevation = !detection.hosts.writable;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iann29/synapse",
-  "version": "1.8.9",
+  "version": "1.8.10",
   "description": "Thin CLI wrapper for using the official Convex CLI with Synapse-managed deployments.",
   "license": "Apache-2.0",
   "repository": {