dinou 6.1.1 → 7.0.0

package/dinou/node/port-selector.mjs

@@ -0,0 +1,164 @@
+// dinou/node/port-selector.mjs
+// Interactive development port detection and fallback for Dinou.
+// Ensures dual consecutive free ports (HTTP server + HMR / WebSocket server)
+// across all supported bundlers (esbuild, rollup, webpack).
+
+import net from "node:net";
+import readline from "node:readline";
+
+const C_RESET = "\x1b[0m";
+const C_BOLD = "\x1b[1m";
+const C_DIM = "\x1b[90m";
+const C_CYAN = "\x1b[36m";
+const C_GREEN = "\x1b[32m";
+const C_YELLOW = "\x1b[33m";
+const C_RED = "\x1b[31m";
+
+/**
+ * Checks if a TCP port is currently free on both default and IPv4 loopback.
+ * @param {number} port
+ * @returns {Promise<boolean>}
+ */
+export function isPortAvailable(port) {
+  return new Promise((resolve) => {
+    // 1. Try active connection to 127.0.0.1
+    const client = net.connect({ port, host: "127.0.0.1" });
+    client.once("connect", () => {
+      client.destroy();
+      resolve(false);
+    });
+    client.once("error", () => {
+      client.destroy();
+      // 2. Try listening on default host
+      const s1 = net.createServer();
+      s1.unref();
+      s1.once("error", () => resolve(false));
+      s1.once("listening", () => {
+        s1.close(() => {
+          // 3. Try listening specifically on 127.0.0.1
+          const s2 = net.createServer();
+          s2.unref();
+          s2.once("error", () => resolve(false));
+          s2.once("listening", () => {
+            s2.close(() => resolve(true));
+          });
+          s2.listen(port, "127.0.0.1");
+        });
+      });
+      s1.listen(port);
+    });
+  });
+}
+
+/**
+ * Checks if both server port and companion HMR port are available.
+ * @param {number} serverPort
+ * @param {number} hmrPort
+ * @returns {Promise<boolean>}
+ */
+export async function arePortsAvailable(serverPort, hmrPort) {
+  const isServerFree = await isPortAvailable(serverPort);
+  if (!isServerFree) return false;
+  const isHmrFree = await isPortAvailable(hmrPort);
+  return isHmrFree;
+}
+
+/**
+ * Finds the next available pair of consecutive ports [P, P+1].
+ * Keeps even/odd parity so HTTP servers remain on even ports.
+ * @param {number} startPort
+ * @returns {Promise<number>}
+ */
+export async function findAvailablePortPair(startPort = 3000) {
+  let current = startPort;
+  while (current < 65534) {
+    if (await arePortsAvailable(current, current + 1)) {
+      return current;
+    }
+    current += current % 2 === 0 ? 2 : 1;
+  }
+  throw new Error("No available port pair found");
+}
+
+/**
+ * Prompts the user interactively in the terminal via readline.
+ * @param {string} question
+ * @returns {Promise<boolean>}
+ */
+function promptUser(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    rl.on("SIGINT", () => {
+      rl.close();
+      console.log(`\n\n  ${C_RED}❌ Server startup aborted by user.${C_RESET}\n`);
+      process.exit(0);
+    });
+
+    rl.question(question, (answer) => {
+      rl.close();
+      const trimmed = answer.trim().toLowerCase();
+      if (trimmed === "" || trimmed === "y" || trimmed === "yes") {
+        resolve(true);
+      } else {
+        resolve(false);
+      }
+    });
+  });
+}
+
+/**
+ * Resolves dev server ports.
+ * In development, if the target port (or HMR port) is in use:
+ * - In interactive TTY: prompts the user to switch to the next consecutive free port pair.
+ * - In non-interactive environments (CI, scripts): exits immediately with an error.
+ * @returns {Promise<{ port: number, hmrPort: number }>}
+ */
+export async function resolveDevPorts() {
+  const requestedPort = Number(process.env.PORT || 3000);
+  const requestedHmrPort = Number(process.env.HMR_PORT || (requestedPort + 1));
+
+  const isServerFree = await isPortAvailable(requestedPort);
+  const isHmrFree = await isPortAvailable(requestedHmrPort);
+
+  if (isServerFree && isHmrFree) {
+    process.env.PORT = String(requestedPort);
+    process.env.HMR_PORT = String(requestedHmrPort);
+    return { port: requestedPort, hmrPort: requestedHmrPort };
+  }
+
+  const busyPort = !isServerFree ? requestedPort : requestedHmrPort;
+
+  // Non-interactive environments (CI, pipes) cannot prompt user
+  const isInteractive = Boolean(
+    (process.stdout.isTTY || process.env.DINOU_FORCE_INTERACTIVE === "true") &&
+    !process.env.CI &&
+    process.env.TERM !== "dumb"
+  );
+
+  if (!isInteractive) {
+    console.error(`\n❌ FATAL ERROR: Port ${busyPort} is already in use!\n`);
+    process.exit(1);
+  }
+
+  // Find next consecutive pair (e.g. 3002 & 3003)
+  const fallbackPort = await findAvailablePortPair(requestedPort + 2);
+  const fallbackHmrPort = fallbackPort + 1;
+
+  const confirmed = await promptUser(
+    `\n  ${C_YELLOW}⚠️  Port ${busyPort} is in use.${C_RESET}\n  ${C_BOLD}? Would you like to use port ${fallbackPort} instead?${C_RESET} ${C_DIM}(Y/n)${C_RESET} `
+  );
+
+  if (!confirmed) {
+    console.log(`\n  ${C_RED}❌ Server startup aborted by user.${C_RESET}\n`);
+    process.exit(0);
+  }
+
+  console.log(`\n  ${C_GREEN}➜${C_RESET}  ${C_BOLD}Using port:${C_RESET} ${C_CYAN}${fallbackPort}${C_RESET} ${C_DIM}(HMR: ${fallbackHmrPort})${C_RESET}\n`);
+  process.env.PORT = String(fallbackPort);
+  process.env.HMR_PORT = String(fallbackHmrPort);
+  return { port: fallbackPort, hmrPort: fallbackHmrPort };
+}

package/dinou/node/terminal-status.mjs

@@ -0,0 +1,345 @@
+// dinou/node/terminal-status.mjs
+// Lightweight terminal status & animated spinner for Dinou Development Server.
+// Zero external dependencies. Fully TTY-aware and safe for CI/Playwright.
+
+import readline from "node:readline";
+
+export const isTTY = Boolean(
+  process.stdout.isTTY && !process.env.CI && process.env.TERM !== "dumb"
+);
+
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const C_RESET = "\x1b[0m";
+const C_BOLD = "\x1b[1m";
+const C_DIM = "\x1b[90m";
+const C_CYAN = "\x1b[36m";
+const C_GREEN = "\x1b[32m";
+const C_YELLOW = "\x1b[33m";
+const C_MAGENTA = "\x1b[35m";
+
+export function getTerminalCols() {
+  if (process.stdout.isTTY) {
+    if (typeof process.stdout._refreshSize === "function") {
+      try {
+        process.stdout._refreshSize();
+      } catch (e) {}
+    }
+    if (typeof process.stdout.getWindowSize === "function") {
+      try {
+        const [w] = process.stdout.getWindowSize();
+        if (w > 0) return w;
+      } catch (e) {}
+    }
+    return process.stdout.columns || 80;
+  }
+  return 80;
+}
+
+let active = false;
+let frameIdx = 0;
+let currentText = "";
+let timer = null;
+let isWatching = false;
+
+// Intercept stdout/stderr writes so normal logs don't collide with the spinner line
+let hooked = false;
+const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+const originalStderrWrite = process.stderr.write.bind(process.stderr);
+
+function hookStreams() {
+  if (hooked || !isTTY) return;
+  hooked = true;
+
+  process.stdout.write = function (chunk, encoding, callback) {
+    if (active) {
+      originalStdoutWrite("\r\x1b[2K");
+    }
+    const result = originalStdoutWrite(chunk, encoding, callback);
+    if (active) {
+      render();
+    }
+    return result;
+  };
+
+  process.stderr.write = function (chunk, encoding, callback) {
+    if (active) {
+      originalStdoutWrite("\r\x1b[2K");
+    }
+    const result = originalStderrWrite(chunk, encoding, callback);
+    if (active) {
+      render();
+    }
+    return result;
+  };
+}
+
+function render() {
+  if (!active || !isTTY) return;
+  const cols = getTerminalCols();
+  if (cols <= 0) return;
+  if (cols < 8) {
+    const frame = FRAMES[frameIdx];
+    originalStdoutWrite(`\r\x1b[2K${frame}\x1b[K\x1b[J`);
+    return;
+  }
+  const maxTextLen = Math.max(1, cols - 6);
+  let text = currentText;
+  if (text.length > maxTextLen) {
+    text = text.slice(0, Math.max(1, maxTextLen - 3)) + "...";
+  }
+  const frame = FRAMES[frameIdx];
+  const line = `\r\x1b[2K  ${C_CYAN}${C_BOLD}${frame}${C_RESET} ${text}\x1b[K\x1b[J`;
+  originalStdoutWrite(line);
+}
+
+export function startSpinner(text) {
+  if (!isTTY) return;
+  hookStreams();
+  currentText = text;
+  active = true;
+  frameIdx = 0;
+  if (!timer) {
+    timer = setInterval(() => {
+      frameIdx = (frameIdx + 1) % FRAMES.length;
+      render();
+    }, 80);
+    timer.unref();
+  }
+  render();
+}
+
+export function updateSpinner(text) {
+  currentText = text;
+  if (isTTY && active) {
+    render();
+  }
+}
+
+export function stopSpinner() {
+  active = false;
+  if (timer) {
+    clearInterval(timer);
+    timer = null;
+  }
+  if (isTTY) {
+    originalStdoutWrite("\r\x1b[2K\x1b[J\r");
+  }
+}
+
+let buildFrameIdx = 0;
+let buildTimer = null;
+let currentBuildText = "";
+let isBuildActive = false;
+
+function smartTruncate(text, maxLen) {
+  if (text.length <= maxLen) return text;
+  const m = text.match(/^(\[SSG\].*?:\s+)(.*)$/);
+  if (m) {
+    const prefix = m[1];
+    const route = m[2];
+    const avail = maxLen - prefix.length;
+    if (avail > 10) {
+      const half = Math.floor((avail - 3) / 2);
+      return prefix + route.slice(0, half) + "..." + route.slice(route.length - (avail - 3 - half));
+    }
+  }
+  if (maxLen <= 3) {
+    return text.slice(0, maxLen);
+  }
+  return text.slice(0, maxLen - 3) + "...";
+}
+
+let lastBuildLineLen = 0;
+let lastBuildCols = 0;
+
+function renderBuildProgress() {
+  if (!isBuildActive || !isTTY) return;
+  const cols = getTerminalCols();
+  if (cols <= 0) return;
+
+  // Ultra-narrow terminal (< 8 cols): render just the spinner frame to guarantee 0 wrapping
+  if (cols < 8) {
+    const frame = FRAMES[buildFrameIdx];
+    buildFrameIdx = (buildFrameIdx + 1) % FRAMES.length;
+    lastBuildLineLen = 1;
+    lastBuildCols = cols;
+    process.stdout.write(`\r\x1b[2K${frame}\x1b[K\x1b[J`);
+    return;
+  }
+
+  // If terminal narrowed since last render, the previous line reflowed across multiple physical rows.
+  // Move up linesOccupied - 1 rows and clear each one to stay on a single line!
+  if (lastBuildLineLen > 0 && lastBuildCols > cols) {
+    const linesOccupied = Math.min(3, Math.ceil(lastBuildLineLen / Math.max(1, cols)));
+    if (linesOccupied > 1) {
+      for (let i = 0; i < linesOccupied - 1; i++) {
+        process.stdout.write("\x1b[1A\r\x1b[2K");
+      }
+    }
+  }
+
+  // Dynamically adapt to full terminal width with a 2-column margin against auto-wrap
+  const maxLineLen = Math.max(4, cols - 2);
+  const maxTextLen = Math.max(1, maxLineLen - 4);
+
+  const safeText = smartTruncate(currentBuildText, maxTextLen);
+
+  const frame = FRAMES[buildFrameIdx];
+  buildFrameIdx = (buildFrameIdx + 1) % FRAMES.length;
+
+  lastBuildLineLen = safeText.length + 4;
+  lastBuildCols = cols;
+
+  // \r (carriage return) + \x1b[2K (clear line) + text + \x1b[K (clear trailing) + \x1b[J (clear all lines below)
+  process.stdout.write(`\r\x1b[2K  ${C_CYAN}${C_BOLD}${frame}${C_RESET} ${safeText}\x1b[K\x1b[J`);
+}
+
+export function updateBuildProgress(text) {
+  if (!isTTY) return;
+  currentBuildText = text;
+  if (!isBuildActive) {
+    isBuildActive = true;
+    buildFrameIdx = 0;
+    lastBuildLineLen = 0;
+    lastBuildCols = 0;
+    // Hide cursor for smooth, flicker-free rendering
+    process.stdout.write("\x1b[?25l");
+    renderBuildProgress();
+    if (!buildTimer) {
+      buildTimer = setInterval(renderBuildProgress, 80);
+      if (buildTimer.unref) buildTimer.unref();
+    }
+  }
+}
+
+export function clearBuildProgress() {
+  if (!isTTY) return;
+  isBuildActive = false;
+  lastBuildLineLen = 0;
+  lastBuildCols = 0;
+  if (buildTimer) {
+    clearInterval(buildTimer);
+    buildTimer = null;
+  }
+  // Clear the line, clear any lines below, and restore cursor visibility
+  process.stdout.write("\r\x1b[2K\x1b[J\x1b[?25h");
+}
+
+// Debounce terminal resize events so mouse dragging does not flood stdout
+let resizeTimer = null;
+if (typeof process.stdout.on === "function") {
+  process.stdout.on("resize", () => {
+    if (isBuildActive && isTTY) {
+      if (!resizeTimer) {
+        resizeTimer = setTimeout(() => {
+          resizeTimer = null;
+          renderBuildProgress();
+        }, 40);
+        if (resizeTimer.unref) resizeTimer.unref();
+      }
+    }
+  });
+}
+
+// Ensure cursor is always restored on process exit
+process.on("exit", () => {
+  if (isTTY) {
+    try {
+      process.stdout.write("\x1b[?25h");
+    } catch (e) {}
+  }
+});
+
+export function logSuccess(text) {
+  stopSpinner();
+  console.log(`  ${C_GREEN}✓${C_RESET} ${text}`);
+  if (isWatching) {
+    showIdleStatus();
+  }
+}
+
+export function logInfo(text) {
+  stopSpinner();
+  console.log(`  ${C_CYAN}ℹ${C_RESET} ${text}`);
+  if (isWatching) {
+    showIdleStatus();
+  }
+}
+
+export function showIdleStatus() {
+  if (!isTTY) return;
+  startSpinner(`${C_DIM}watching for file changes...${C_RESET}`);
+}
+
+export function printReadyBanner({ port, tool, durationMs, timings }) {
+  stopSpinner();
+  isWatching = true;
+
+  const durationStr = durationMs ? `${durationMs}ms` : "";
+  const timeBadge = durationStr ? ` ${C_DIM}in ${C_BOLD}${durationStr}${C_RESET}` : "";
+
+  console.log("");
+  console.log(`  ${C_CYAN}${C_BOLD}🦖 Dinou v7${C_RESET} ${C_GREEN}(Dual-Bundle, 0-fork)${C_RESET}${timeBadge}`);
+  console.log("");
+  console.log(`  ${C_GREEN}➜${C_RESET}  ${C_BOLD}Local:${C_RESET}   ${C_CYAN}http://localhost:${port}/${C_RESET}`);
+  console.log(`  ${C_GREEN}➜${C_RESET}  ${C_BOLD}Bundler:${C_RESET} ${tool}`);
+  const isDebug =
+    process.env.DINOU_DEBUG === "true" ||
+    process.env.DINOU_DEBUG === "1" ||
+    process.env.DEBUG === "true" ||
+    process.env.DEBUG === "1";
+
+  if (timings && isDebug) {
+    console.log("");
+    console.log(`  ${C_BOLD}⚡ Startup Breakdown:${C_RESET}`);
+    if (timings.discovery != null) {
+      console.log(`    ${C_DIM}├─ Discovery & Routing:${C_RESET}       ${C_CYAN}${timings.discovery}ms${C_RESET}`);
+    }
+    if (timings.engineBuild != null) {
+      console.log(`    ${C_DIM}├─ Dual-Engine (RSC+SSR):${C_RESET}     ${C_CYAN}${timings.engineBuild}ms${C_RESET}`);
+    }
+    if (timings.engineImport != null) {
+      console.log(`    ${C_DIM}├─ Engine V8 Evaluation:${C_RESET}     ${C_CYAN}${timings.engineImport}ms${C_RESET}`);
+    }
+    if (timings.clientEntriesBabel != null) {
+      console.log(`    ${C_DIM}├─ Client Babel AST Scan:${C_RESET}    ${C_CYAN}${timings.clientEntriesBabel}ms${C_RESET}`);
+    }
+    if (timings.clientBuild != null) {
+      console.log(`    ${C_DIM}├─ Client Bundling (esbuild):${C_RESET} ${C_CYAN}${timings.clientBuild}ms${C_RESET}`);
+      const subParts = [];
+      if (timings.postCss) subParts.push(`PostCSS: ${timings.postCss}ms (${timings.postCssCount || 0} css)`);
+      if (timings.swc) subParts.push(`SWC Refresh: ${timings.swc}ms (${timings.swcCount || 0} files)`);
+      if (timings.sf) subParts.push(`Server Actions: ${timings.sf}ms (${timings.sfCount || 0} files)`);
+      if (timings.rcm) subParts.push(`Client Manifest: ${timings.rcm}ms`);
+      if (timings.stable) subParts.push(`Stable Chunks: ${timings.stable}ms`);
+      if (timings.writeDisk != null) {
+        if (timings.writeDisk === 0) {
+          subParts.push("Memory: 0ms (disk skipped)");
+        } else {
+          subParts.push(`Disk Write: ${timings.writeDisk}ms`);
+        }
+      }
+      if (subParts.length > 0) {
+        console.log(`    ${C_DIM}│  └─ [${subParts.join(" | ")}]${C_RESET}`);
+      }
+    } else if (timings.clientBundlerTotal != null) {
+      console.log(`    ${C_DIM}├─ Client Bundler Total:${C_RESET}     ${C_CYAN}${timings.clientBundlerTotal}ms${C_RESET}`);
+    }
+    console.log(`    ${C_DIM}└─ Total Startup Time:${C_RESET}       ${C_GREEN}${C_BOLD}${durationMs}ms${C_RESET}`);
+  }
+
+  console.log("");
+  showIdleStatus();
+}
+
+export default {
+  startSpinner,
+  updateSpinner,
+  stopSpinner,
+  updateBuildProgress,
+  clearBuildProgress,
+  logSuccess,
+  logInfo,
+  showIdleStatus,
+  printReadyBanner,
+};

package/dinou/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dinou-ejected",
-  "version": "6.1.1",
+  "version": "7.0.0",
   "main": "index.js",
   "private": true,
   "exports": {
@@ -16,7 +16,17 @@
       "types": "./server.d.ts",
       "import": "./server.mjs",
       "require": "./server.js"
-    }
+    },
+    "./config": {
+      "types": "./index.d.ts",
+      "import": "./core/config.js",
+      "require": "./core/config.js"
+    },
+    "./adapters/node": "./adapters/node.mjs",
+    "./adapters/bun": "./adapters/bun.js",
+    "./adapters/deno": "./adapters/deno.js",
+    "./adapters/cloudflare": "./adapters/cloudflare.js",
+    "./adapters/netlify": "./adapters/netlify.js"
   },
   "types": "./index.d.ts",
   "scripts": {
@@ -26,13 +36,11 @@
     "@babel/core": "^7.27.4",
     "@babel/parser": "^7.28.3",
     "@babel/plugin-syntax-import-meta": "^7.10.4",
-    "@babel/plugin-transform-modules-commonjs": "^7.27.1",
     "@babel/preset-react": "^7.27.1",
     "@babel/preset-typescript": "^7.27.1",
-    "@babel/register": "^7.27.1",
     "@babel/traverse": "^7.28.3",
     "@esbuild-plugins/tsconfig-paths": "^0.1.2",
-    "@roggc/react-server-dom-esm": "^0.0.0-b061b597-20251212",
+    "@roggc/react-server-dom-esm": "^19.3.0",
     "@rollup/plugin-babel": "^6.0.4",
     "@rollup/plugin-commonjs": "^28.0.6",
     "@rollup/plugin-json": "^6.1.0",
@@ -45,32 +53,26 @@
     "babel-plugin-react-compiler": "^1.0.0",
     "chokidar": "^4.0.3",
     "commander": "^14.0.0",
-    "concurrently": "^10.0.3",
-    "cookie-parser": "^1.4.7",
     "copy-webpack-plugin": "^14.0.0",
     "cross-env": "^7.0.3",
     "css-loader": "^7.1.2",
     "dotenv": "^16.5.0",
     "esbuild": "^0.27.0",
     "esbuild-copy-static-files": "^0.1.0",
-    "express": "^5.1.0",
     "generic-names": "^4.0.0",
-    "loader-utils": "^3.3.1",
     "mini-css-extract-plugin": "^2.9.4",
-    "multer": "^2.0.2",
     "postcss": "^8.5.5",
     "postcss-import": "^16.1.1",
     "postcss-loader": "^8.2.0",
     "postcss-modules": "^6.0.1",
     "react-refresh": "^0.17.0",
-    "react-server-dom-webpack": "^19.2.3",
+    "react-server-dom-webpack": "^19.3.0",
     "rollup": "^4.46.2",
     "rollup-plugin-copy": "^3.5.0",
     "rollup-plugin-delete": "^3.0.1",
     "rollup-plugin-postcss": "^4.0.2",
     "rollup-plugin-tsconfig-paths": "^1.5.2",
     "tailwindcss": "^4.1.10",
-    "tsconfig-paths": "^4.2.0",
     "tsconfig-paths-webpack-plugin": "^4.2.0",
     "webpack": "^5.103.0",
     "webpack-cli": "^6.0.1",
@@ -78,7 +80,7 @@
     "ws": "^8.18.3"
   },
   "peerDependencies": {
-    "react": ">=19.2.3",
-    "react-dom": ">=19.2.3"
+    "react": ">=19.3.0",
+    "react-dom": ">=19.3.0"
   }
 }