npm - weifuwu - Versions diffs - 0.8.2 → 0.9.1 - Mend

weifuwu 0.8.2 → 0.9.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/README.md CHANGED Viewed

@@ -853,7 +853,23 @@ import { tsx } from 'weifuwu/tsx'
 const app = new Router()
 app.use('/', await tsx({ dir: './pages/' }))
-serve(app.handler(), { port: 3000 })
+serve(app.handler(), { port: 3000, websocket: app.websocketHandler() })
+```
+### Development mode
+`tsx()` automatically runs in development mode (`NODE_ENV !== 'production'`):
+- **File watching** — editing a `.tsx`/`.ts` file triggers recompilation and the browser auto-refreshes via WebSocket
+- **Tailwind CSS** — if an `app.css` or `globals.css` file is found, Tailwind CSS is processed automatically. Write `className` directly.
+- **`@` aliases** — if `tsconfig.json` or `jsconfig.json` has `compilerOptions.paths`, the `@` alias is passed to esbuild automatically (works with shadcn/ui)
+- **Process state preserved** — DB connections, WebSockets, in-memory caches are not lost
+Production mode (`NODE_ENV=production`) disables file watching and live reload. All other features work the same.
+```bash
+node app.ts                # development
+NODE_ENV=production node app.ts   # production
 ```
 ### File conventions
@@ -947,12 +963,12 @@ app.use('/graphql', graphql(() => ({ schema: `type Query { hello: String }`, res
 app.use('/agent', workflow(() => ({ tools: myTools, stream: true })))
 app.ws('/chat', { message(ws, _, data) { ws.send(data) } })
-serve(app.handler())
+serve(app.handler(), { websocket: app.websocketHandler() })
 ```
 ```bash
-node --watch app.ts    # development
-node app.ts            # production
+node app.ts                # development (auto-reload on changes)
+NODE_ENV=production node app.ts   # production
 ```
 No build step, no configuration file — just Node.js.
@@ -1094,10 +1110,25 @@ Returns `MessagerModule` — `{ migrate, router, wsHandler, send, close }`.
 | Option | Default | Description |
 |--------|---------|-------------|
-| `dir` | — | Pages directory path |
+| `dir`  | —       | Pages directory path |
 Returns `Promise<Router>`.
+Development features (auto-detected, no configuration needed):
+| Feature | Behavior |
+|---------|----------|
+| **File watching** | Enabled when `NODE_ENV !== 'production'`. Watches pages directory, recompiles on change, sends live-reload signal via WebSocket |
+| **Tailwind CSS** | Auto-detected when `app.css` / `globals.css` exists. Processed through PostCSS + Tailwind plugin. Served at `/__wfw/style.css` and auto-injected into HTML `<head>` |
+| **`@` alias** | Read from `tsconfig.json` / `jsconfig.json` `compilerOptions.paths` and passed to esbuild |
+| **WebSocket live reload** | Endpoint at `/__weifuwu/livereload`. Browser auto-refreshes on file changes or server restart |
+To use WebSocket features, pass `router.websocketHandler()` to `serve()`:
+```ts
+serve(app.handler(), { websocket: app.websocketHandler() })
+```
 ### `Router`
 | Method | Description |

package/dist/index.js CHANGED Viewed

@@ -109,7 +109,10 @@ function serve(handler, options) {
   });
   return {
     stop: () => {
-      server.close();
+      return new Promise((resolve3) => {
+        server.closeAllConnections();
+        server.close(() => resolve3());
+      });
     },
     ready,
     get port() {
@@ -293,44 +296,51 @@ var Router = class _Router {
       const segments = url.pathname.split("/").filter(Boolean);
       const query = Object.fromEntries(url.searchParams);
       const match = router.matchWsTrie(wsRoot, segments);
-      if (!match) {
-        socket.destroy();
+      if (match) {
+        const webReq = new Request(url.href, {
+          method: req.method ?? "GET",
+          headers: Object.fromEntries(
+            Object.entries(req.headers).map(([k, v]) => [k, Array.isArray(v) ? v.join(", ") : v ?? ""])
+          )
+        });
+        const ctx = { params: match.params, query };
+        if (match.middlewares.length === 0) {
+          upgradeSocket(wss, req, socket, head, match.handler, ctx);
+          return;
+        }
+        let index = 0;
+        const dispatch = async (innerReq, ctx2) => {
+          if (index < match.middlewares.length) {
+            const mw = match.middlewares[index++];
+            return mw(innerReq, ctx2, dispatch);
+          }
+          return await new Promise((resolve3) => {
+            try {
+              upgradeSocket(wss, req, socket, head, match.handler, ctx2);
+              resolve3(new Response(null, { status: 101 }));
+            } catch {
+              socket.destroy();
+              resolve3(new Response("WebSocket upgrade failed", { status: 500 }));
+            }
+          });
+        };
+        Promise.resolve(dispatch(webReq, ctx)).then((result) => {
+          if (result.status !== 101) {
+            sendHttpResponseOnSocket(socket, result);
+          }
+        }).catch(() => {
+          socket.destroy();
+        });
         return;
       }
-      const webReq = new Request(url.href, {
-        method: req.method ?? "GET",
-        headers: Object.fromEntries(
-          Object.entries(req.headers).map(([k, v]) => [k, Array.isArray(v) ? v.join(", ") : v ?? ""])
-        )
-      });
-      const ctx = { params: match.params, query };
-      if (match.middlewares.length === 0) {
-        upgradeSocket(wss, req, socket, head, match.handler, ctx);
+      const httpMatch = router.matchTrie("GET", segments);
+      if (httpMatch?.subRouter) {
+        const remaining = "/" + segments.slice(httpMatch.subRouter.remainingIdx).join("/");
+        req.url = remaining;
+        httpMatch.subRouter.router.websocketHandler()(req, socket, head);
         return;
       }
-      let index = 0;
-      const dispatch = async (innerReq, ctx2) => {
-        if (index < match.middlewares.length) {
-          const mw = match.middlewares[index++];
-          return mw(innerReq, ctx2, dispatch);
-        }
-        return await new Promise((resolve3) => {
-          try {
-            upgradeSocket(wss, req, socket, head, match.handler, ctx2);
-            resolve3(new Response(null, { status: 101 }));
-          } catch {
-            socket.destroy();
-            resolve3(new Response("WebSocket upgrade failed", { status: 500 }));
-          }
-        });
-      };
-      Promise.resolve(dispatch(webReq, ctx)).then((result) => {
-        if (result.status !== 101) {
-          sendHttpResponseOnSocket(socket, result);
-        }
-      }).catch(() => {
-        socket.destroy();
-      });
+      socket.destroy();
     };
   }
   splitPath(path2) {
@@ -492,14 +502,64 @@ function sendHttpResponseOnSocket(socket, response) {
 import { createElement, createContext, useContext } from "react";
 import { renderToReadableStream } from "react-dom/server";
 import * as esbuild from "esbuild";
-import { readdirSync, statSync, existsSync, mkdirSync } from "node:fs";
-import { join, relative, resolve, sep, dirname } from "node:path";
+import { readdirSync, statSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import chokidar from "chokidar";
+import { join, relative, resolve, sep, dirname, basename } from "node:path";
 import { pathToFileURL } from "node:url";
 import { createHash } from "node:crypto";
 var TsxContext = createContext({ params: {}, query: {} });
 function useTsx() {
   return useContext(TsxContext);
 }
+var pageModules = /* @__PURE__ */ new Map();
+var layoutModules = /* @__PURE__ */ new Map();
+var loadModules = /* @__PURE__ */ new Map();
+var routeModules = /* @__PURE__ */ new Map();
+var clientBundles = /* @__PURE__ */ new Map();
+var liveReloadClients = /* @__PURE__ */ new Set();
+var _watcher = null;
+var _cssWatcher = null;
+function broadcastReload() {
+  for (const ws of liveReloadClients) {
+    try {
+      ws.send("reload");
+    } catch {
+      liveReloadClients.delete(ws);
+    }
+  }
+}
+var tailwindCssUrl = null;
+var tailwindCssCode = "";
+var _projectDir = "";
+var _watcherStarted = false;
+var _alias = null;
+function resolveAliases() {
+  if (_alias) return _alias;
+  const configFiles = ["tsconfig.json", "jsconfig.json"];
+  for (const file of configFiles) {
+    const p = resolve(file);
+    if (existsSync(p)) {
+      try {
+        const config = JSON.parse(readFileSync(p, "utf-8"));
+        const paths = config.compilerOptions?.paths;
+        if (paths) {
+          const alias = {};
+          for (const [key, values] of Object.entries(paths)) {
+            const cleanKey = key.replace("/*", "");
+            const val = values[0]?.replace("/*", "");
+            if (val) alias[cleanKey] = resolve(dirname(p), val);
+          }
+          _alias = alias;
+          return alias;
+        }
+      } catch {
+      }
+    }
+  }
+  _alias = {};
+  return {};
+}
+var isDev = process.env.NODE_ENV !== "production";
 function id(s) {
   return createHash("md5").update(s).digest("hex").slice(0, 8);
 }
@@ -603,7 +663,7 @@ function resolveLayouts(dir, pagesDir) {
   }
   return layouts.reverse();
 }
-async function compileAll(files, outDir, platform) {
+async function compileAll(files, outDir, platform, alias) {
   const entryPoints = {};
   for (const f of files) {
     entryPoints[id(f)] = f;
@@ -627,23 +687,21 @@ async function compileAll(files, outDir, platform) {
       "@graphql-tools/schema",
       "ai"
     ],
+    alias,
     write: true,
     allowOverwrite: true
   });
 }
 function compiledUrl(filePath, outDir) {
-  const hash = id(join(outDir, id(filePath)));
   const p = join(outDir, id(filePath) + ".js");
   return pathToFileURL(p).href;
 }
-var clientBundleCache = /* @__PURE__ */ new Map();
 var clientRouteLog = /* @__PURE__ */ new WeakMap();
 async function getOrBuildClientBundle(entryPath, layoutPaths, pagesDir, router) {
   const key = id(entryPath);
   const url = `/__wfw/client/${key}.js`;
   if (!clientRouteLog.get(router)?.has(url)) {
-    let buf = clientBundleCache.get(key);
-    if (!buf) {
+    if (!clientBundles.has(key)) {
       try {
         const nested = layoutPaths.slice(1);
         const layoutsImport = nested.map(
@@ -669,34 +727,46 @@ async function getOrBuildClientBundle(entryPath, layoutPaths, pagesDir, router)
           format: "esm",
           jsx: "automatic",
           jsxImportSource: "react",
+          alias: resolveAliases(),
           write: false,
           minify: true
         });
-        buf = result.outputFiles[0].contents;
-        clientBundleCache.set(key, buf);
+        clientBundles.set(key, result.outputFiles[0].contents);
       } catch (err) {
         console.error("hydration bundle failed:", err);
         return null;
       }
     }
-    router.get(url, () => new Response(buf, {
-      headers: { "content-type": "application/javascript; charset=utf-8" }
-    }));
+    router.get(url, () => {
+      const buf = clientBundles.get(key);
+      return buf ? new Response(buf, {
+        headers: { "content-type": "application/javascript; charset=utf-8" }
+      }) : new Response("", { status: 500 });
+    });
     const set = clientRouteLog.get(router) ?? /* @__PURE__ */ new Set();
     set.add(url);
     clientRouteLog.set(router, set);
   }
   return { url };
 }
-function makeSsrHandler(Component, loadFn, layouts, entryPath, layoutPaths, pagesDir, router) {
+function makeSsrHandler(entryPath, layoutPaths, loadPath, pagesDir, router) {
   return async (req, ctx) => {
+    const pageMod = pageModules.get(entryPath);
+    if (!pageMod) return new Response("", { status: 500 });
+    const Component = pageMod.default;
+    const loadMod = loadPath ? loadModules.get(loadPath) : void 0;
+    const loadFn = loadMod?.default;
     const loadProps = loadFn ? await loadFn({ params: ctx.params, query: ctx.query }) : {};
     const allProps = { ...loadProps, params: ctx.params, query: ctx.query };
     let element = createElement(Component, allProps);
-    for (let i = layouts.length - 1; i >= 0; i--) {
+    for (let i = layoutPaths.length - 1; i >= 0; i--) {
+      const lp = layoutPaths[i];
+      const LMod = layoutModules.get(lp);
+      if (!LMod) continue;
+      const Layout = LMod.default;
       const isRoot = i === 0;
       element = createElement(
-        layouts[i],
+        Layout,
         isRoot ? { children: element, req, ctx } : { children: element }
       );
     }
@@ -711,9 +781,20 @@ function makeSsrHandler(Component, loadFn, layouts, entryPath, layoutPaths, page
     if (bundle) {
       scripts.push(`<script type="module" src="${bundle.url}"></script>`);
     }
-    const html = `<!DOCTYPE html>
+    let html = `<!DOCTYPE html>
 ${body}
 ${scripts.join("\n")}`;
+    if (tailwindCssUrl && html.includes("</head>")) {
+      html = html.replace(
+        "</head>",
+        `<link rel="stylesheet" href="${tailwindCssUrl}" />
+</head>`
+      );
+    }
+    if (isDev) {
+      html += `
+<script>(function(){var ws=new WebSocket((location.protocol==='https:'?'wss:':'ws:')+'//'+location.host+'/__weifuwu/livereload');ws.onmessage=function(e){if(e.data==='reload')location.reload()};ws.onclose=function(){setTimeout(function(){location.reload()},500)}})()</script>`;
+    }
     return new Response(html, {
       headers: { "content-type": "text/html; charset=utf-8" }
     });
@@ -721,6 +802,7 @@ ${scripts.join("\n")}`;
 }
 async function tsx(options) {
   const pagesDir = resolve(options.dir);
+  _projectDir = resolve(pagesDir, "..");
   const outDir = join(pagesDir, "..", ".weifuwu", "ssr");
   const pages = scanPages(pagesDir);
   if (pages.length === 0) return new Router();
@@ -739,79 +821,102 @@ async function tsx(options) {
     for (const lp of rootLayouts) allFiles.add(lp);
   }
   mkdirSync(outDir, { recursive: true });
-  await compileAll([...allFiles], outDir, "node");
+  const alias = resolveAliases();
+  await compileAll([...allFiles], outDir, "node", alias);
   const router = new Router();
+  const methods = ["POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"];
   for (const p of pages) {
     if (p.routeOnly && p.routePath) {
       const rUrl = compiledUrl(p.routePath, outDir);
       const modR = await import(rUrl);
-      const methods = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"];
-      for (const method of methods) {
-        if (modR[method]) {
-          router.route(method, p.route, modR[method]);
-        }
+      const handlers = /* @__PURE__ */ new Map();
+      for (const m of ["GET", ...methods]) {
+        if (modR[m]) handlers.set(m, modR[m]);
+      }
+      routeModules.set(p.routePath, handlers);
+      router.route(
+        "GET",
+        p.route,
+        (req, ctx) => routeModules.get(p.routePath)?.get("GET")?.(req, ctx) ?? new Response("", { status: 501 })
+      );
+      for (const m of methods) {
+        router.route(
+          m,
+          p.route,
+          (req, ctx) => routeModules.get(p.routePath)?.get(m)?.(req, ctx) ?? new Response("", { status: 501 })
+        );
       }
       continue;
     }
-    const url = compiledUrl(p.entryPath, outDir);
-    const mod = await import(url);
-    const Component = mod.default;
-    let loadFn;
+    const pageUrl = compiledUrl(p.entryPath, outDir);
+    pageModules.set(p.entryPath, await import(pageUrl));
     if (p.loadPath) {
       const loadUrl = compiledUrl(p.loadPath, outDir);
-      const modLoad = await import(loadUrl);
-      loadFn = modLoad.default;
+      loadModules.set(p.loadPath, await import(loadUrl));
     }
-    const layoutComponents = [];
     for (const lp of p.layouts) {
       const lUrl = compiledUrl(lp, outDir);
-      const modL = await import(lUrl);
-      layoutComponents.push(modL.default);
-    }
-    const handler = makeSsrHandler(
-      Component,
-      loadFn,
-      layoutComponents,
-      p.entryPath,
-      p.layouts,
-      pagesDir,
-      router
-    );
-    router.get(p.route, handler);
+      layoutModules.set(lp, await import(lUrl));
+    }
     if (p.routePath) {
       const rUrl = compiledUrl(p.routePath, outDir);
       const modR = await import(rUrl);
-      const methods = ["POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"];
-      for (const method of methods) {
-        if (modR[method]) {
-          router.route(method, p.route, modR[method]);
-        }
+      const handlers = /* @__PURE__ */ new Map();
+      for (const m of methods) {
+        if (modR[m]) handlers.set(m, modR[m]);
+      }
+      routeModules.set(p.routePath, handlers);
+    }
+    const handler = makeSsrHandler(p.entryPath, p.layouts, p.loadPath, pagesDir, router);
+    router.get(p.route, handler);
+    if (p.routePath) {
+      for (const m of methods) {
+        router.route(
+          m,
+          p.route,
+          (req, ctx) => routeModules.get(p.routePath)?.get(m)?.(req, ctx) ?? new Response("", { status: 501 })
+        );
       }
     }
   }
   if (hasNotFound) {
     const nfUrl = compiledUrl(nfPath, outDir);
-    const modNf = await import(nfUrl);
-    const NfComponent = modNf.default;
-    const nfLayouts = [];
+    pageModules.set(nfPath, await import(nfUrl));
     const rootLayouts = resolveLayouts(pagesDir, pagesDir);
     for (const lp of rootLayouts) {
-      const lUrl = compiledUrl(lp, outDir);
-      const modL = await import(lUrl);
-      nfLayouts.push(modL.default);
+      if (!layoutModules.has(lp)) {
+        const lUrl = compiledUrl(lp, outDir);
+        layoutModules.set(lp, await import(lUrl));
+      }
     }
     const handler = async (req, ctx) => {
+      const nfMod = pageModules.get(nfPath);
+      if (!nfMod) return new Response("Not Found", { status: 404 });
+      const NfComponent = nfMod.default;
       let element = createElement(NfComponent, { params: ctx.params, query: ctx.query });
-      for (let i = nfLayouts.length - 1; i >= 0; i--) {
-        element = createElement(nfLayouts[i], { children: element });
+      for (let i = rootLayouts.length - 1; i >= 0; i--) {
+        const LMod = layoutModules.get(rootLayouts[i]);
+        if (!LMod) continue;
+        element = createElement(LMod.default, { children: element });
       }
       element = createElement(TsxContext.Provider, {
         value: { params: ctx.params, query: ctx.query, user: ctx.user, parsed: ctx.parsed }
       }, element);
       const stream = await renderToReadableStream(element);
       const body = await readStream(stream);
-      const html = `<!DOCTYPE html>
+      let html = `<!DOCTYPE html>
 ${body}`;
+      if (tailwindCssUrl && html.includes("</head>")) {
+        html = html.replace(
+          "</head>",
+          `<link rel="stylesheet" href="${tailwindCssUrl}" />
+</head>`
+        );
+      }
+      if (isDev) {
+        html += `
+<script>(function(){var ws=new WebSocket((location.protocol==='https:'?'wss:':'ws:')+'//'+location.host+'/__weifuwu/livereload');ws.onmessage=function(e){if(e.data==='reload')location.reload()};ws.onclose=function(){setTimeout(function(){location.reload()},500)}})()</script>`;
+      }
       return new Response(html, {
         status: 404,
         headers: { "content-type": "text/html; charset=utf-8" }
@@ -819,8 +924,150 @@ ${body}`;
     };
     router.all("/*", handler);
   }
+  tailwindCssUrl = await setupTailwind(pagesDir, router, alias);
+  if (isDev) {
+    router.ws("/__weifuwu/livereload", {
+      open(ws) {
+        liveReloadClients.add(ws);
+        ws.on("close", () => liveReloadClients.delete(ws));
+        ws.on("error", () => liveReloadClients.delete(ws));
+      }
+    });
+    if (!_watcherStarted) {
+      startFileWatcher(pagesDir, outDir);
+      _watcherStarted = true;
+    }
+  }
   return router;
 }
+async function setupTailwind(pagesDir, router, alias) {
+  let tailwindPlugin, postcss, autoprefixer;
+  try {
+    tailwindPlugin = (await import("@tailwindcss/postcss")).default;
+    postcss = (await import("postcss")).default;
+    autoprefixer = (await import("autoprefixer")).default;
+  } catch {
+    return null;
+  }
+  const candidates = ["app.css", "globals.css", "src/app.css", "src/globals.css", "style.css"];
+  let inputFile = "";
+  for (const c of candidates) {
+    const p = resolve(pagesDir, "..", c);
+    if (existsSync(p)) {
+      inputFile = p;
+      break;
+    }
+  }
+  if (!inputFile) return null;
+  try {
+    const src = readFileSync(inputFile, "utf-8");
+    const result = await postcss([tailwindPlugin(), autoprefixer]).process(src, { from: inputFile });
+    tailwindCssCode = result.css;
+  } catch (err) {
+    console.warn("Tailwind CSS processing failed:", err.message);
+    return null;
+  }
+  const url = "/__wfw/style.css";
+  router.get(url, () => new Response(tailwindCssCode, {
+    headers: { "content-type": "text/css; charset=utf-8" }
+  }));
+  if (isDev) {
+    _cssWatcher = chokidar.watch(inputFile, { persistent: false });
+    _cssWatcher.on("change", async () => {
+      try {
+        const newSrc = readFileSync(inputFile, "utf-8");
+        const newResult = await postcss([tailwindPlugin(), autoprefixer]).process(newSrc, { from: inputFile });
+        tailwindCssCode = newResult.css;
+        broadcastReload();
+      } catch (err) {
+        console.warn("Tailwind CSS reprocessing failed:", err.message);
+      }
+    });
+  }
+  return url;
+}
+function startFileWatcher(pagesDir, outDir) {
+  let timeout = null;
+  const pending = /* @__PURE__ */ new Set();
+  _watcher = chokidar.watch(pagesDir, {
+    ignored: /(^|[/\\])\.(?!\.)|\.weifuwu/,
+    persistent: false,
+    ignoreInitial: true
+  });
+  _watcher.on("all", async (event, filePath) => {
+    if (event !== "change" && event !== "add") return;
+    if (!/\.tsx?$/.test(filePath)) return;
+    pending.add(filePath);
+    if (timeout) clearTimeout(timeout);
+    timeout = setTimeout(async () => {
+      timeout = null;
+      const files = [...pending];
+      pending.clear();
+      for (const f of files) {
+        if (existsSync(f)) await recompileAndSwap(f, outDir);
+      }
+    }, 50);
+  });
+}
+async function recompileAndSwap(filePath, outDir) {
+  try {
+    await esbuild.build({
+      entryPoints: { [id(filePath)]: filePath },
+      outdir: outDir,
+      alias: resolveAliases(),
+      format: "esm",
+      platform: "node",
+      jsx: "automatic",
+      jsxImportSource: "react",
+      bundle: true,
+      external: ["react", "react-dom", "esbuild", "graphql", "ws", "zod", "@graphql-tools/schema", "ai"],
+      write: true,
+      allowOverwrite: true
+    });
+    const bustUrl = compiledUrl(filePath, outDir) + "?t=" + Date.now();
+    const freshMod = await import(bustUrl);
+    const name15 = basename(filePath);
+    if (name15 === "layout.tsx") {
+      layoutModules.set(filePath, freshMod);
+    } else if (name15 === "route.ts") {
+      const handlers = /* @__PURE__ */ new Map();
+      for (const m of ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]) {
+        if (freshMod[m]) handlers.set(m, freshMod[m]);
+      }
+      routeModules.set(filePath, handlers);
+    } else if (name15 === "load.ts") {
+      loadModules.set(filePath, freshMod);
+    } else {
+      pageModules.set(filePath, freshMod);
+      clientBundles.delete(id(filePath));
+    }
+    if (tailwindCssUrl) {
+      try {
+        const tailwindPlugin = (await import("@tailwindcss/postcss")).default;
+        const postcss = (await import("postcss")).default;
+        const autoprefixer = (await import("autoprefixer")).default;
+        const candidates = ["app.css", "globals.css", "src/app.css", "src/globals.css", "style.css"];
+        let inputFile = "";
+        for (const c of candidates) {
+          const p = resolve(_projectDir, c);
+          if (existsSync(p)) {
+            inputFile = p;
+            break;
+          }
+        }
+        if (inputFile) {
+          const newSrc = readFileSync(inputFile, "utf-8");
+          const result = await postcss([tailwindPlugin(), autoprefixer]).process(newSrc, { from: inputFile });
+          tailwindCssCode = result.css;
+        }
+      } catch {
+      }
+    }
+    broadcastReload();
+  } catch (err) {
+    console.error("recompile failed:", err.message);
+  }
+}
 // middleware.ts
 function logger(options) {

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "weifuwu",
-  "version": "0.8.2",
+  "version": "0.9.1",
   "description": "Web-standard HTTP framework for Node.js — (req, ctx) => Response",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -14,21 +14,26 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "esbuild index.ts --bundle --format=esm --platform=node --outfile=dist/index.js --external:react --external:react-dom --external:esbuild --external:graphql --external:ws --external:zod --external:@graphql-tools/schema --external:ai --external:postgres --external:jsonwebtoken --external:ioredis",
+    "build": "esbuild index.ts --bundle --format=esm --platform=node --outfile=dist/index.js --external:react --external:react-dom --external:esbuild --external:graphql --external:ws --external:zod --external:@graphql-tools/schema --external:ai --external:postgres --external:jsonwebtoken --external:ioredis --external:chokidar --external:tailwindcss --external:@tailwindcss/* --external:postcss --external:autoprefixer --external:lightningcss",
     "prepublishOnly": "npm run build && tsc --emitDeclarationOnly --outdir dist",
     "test": "node --test 'test/**/*.test.ts'"
   },
   "dependencies": {
     "@ai-sdk/openai": "^3.0.66",
     "@graphql-tools/schema": "^10",
+    "@tailwindcss/postcss": "^4",
     "ai": "^6",
+    "autoprefixer": "^10",
+    "chokidar": "^5.0.0",
     "esbuild": "^0.28.0",
     "graphql": "^16",
     "ioredis": "^5.11.0",
     "jsonwebtoken": "^9.0.3",
+    "postcss": "^8",
     "postgres": "^3.4.9",
     "react": "^19",
     "react-dom": "^19",
+    "tailwindcss": "^4",
     "ws": "^8",
     "zod": "^4.4.3"
   },