npm - weifuwu - Versions diffs - 0.8.0 → 0.9.0 - Mend

weifuwu 0.8.0 → 0.9.0

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 (4) 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

@@ -10718,9 +10718,24 @@ var require_built3 = __commonJS({
 // serve.ts
 import http from "node:http";
-async function readBody(req) {
+async function readBody(req, maxSize) {
+  if (maxSize) {
+    const cl = parseInt(req.headers["content-length"] ?? "0", 10);
+    if (cl > maxSize) {
+      const err = new Error("Request body too large");
+      err.status = 413;
+      throw err;
+    }
+  }
   const chunks = [];
+  let total = 0;
   for await (const chunk of req) {
+    total += chunk.byteLength;
+    if (maxSize && total > maxSize) {
+      const err = new Error("Request body too large");
+      err.status = 413;
+      throw err;
+    }
     chunks.push(chunk);
   }
   return Buffer.concat(chunks);
@@ -10766,11 +10781,16 @@ function serve(handler, options) {
   const hostname = options?.hostname ?? "0.0.0.0";
   const server = http.createServer(async (req, res) => {
     try {
-      const body = await readBody(req);
+      const body = await readBody(req, options?.maxBodySize);
       const [request, query] = createRequest(req, body);
       const response = await handler(request, { params: {}, query });
       await sendResponse(res, response);
-    } catch {
+    } catch (err) {
+      if (err?.status === 413) {
+        res.writeHead(413, { "Content-Type": "text/plain" });
+        res.end("Request Body Too Large");
+        return;
+      }
       res.writeHead(500, { "Content-Type": "text/plain" });
       res.end("Internal Server Error");
     }
@@ -10807,7 +10827,10 @@ function serve(handler, options) {
   });
   return {
     stop: () => {
-      server.close();
+      return new Promise((resolve3) => {
+        server.closeAllConnections();
+        server.close(() => resolve3());
+      });
     },
     ready,
     get port() {
@@ -10991,39 +11014,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) => {
-          upgradeSocket(wss, req, socket, head, match.handler, ctx2);
-          resolve3(new Response(null, { status: 101 }));
-        });
-      };
-      Promise.resolve(dispatch(webReq, ctx)).then((result) => {
-        if (result.status !== 101) {
-          sendHttpResponseOnSocket(socket, result);
-        }
-      }).catch(() => {
-        socket.destroy();
-      });
+      socket.destroy();
     };
   }
   splitPath(path2) {
@@ -11185,14 +11220,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);
 }
@@ -11296,7 +11381,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;
@@ -11320,23 +11405,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(
@@ -11362,34 +11445,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 }
       );
     }
@@ -11404,9 +11499,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" }
     });
@@ -11414,6 +11520,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();
@@ -11432,79 +11539,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" }
@@ -11512,8 +11642,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) {
@@ -11815,7 +12087,7 @@ function validate(schemas) {
     if (issues.length > 0) {
       return Response.json({ error: "Validation failed", issues }, { status: 400 });
     }
-    ctx.parsed = parsed;
+    ctx.parsed = { ...ctx.parsed, ...parsed };
     return next(req, ctx);
   };
 }
@@ -11831,7 +12103,11 @@ function getCookies(req) {
     const name15 = pair.slice(0, idx).trim();
     const value = pair.slice(idx + 1).trim();
     if (name15) {
-      cookies[name15] = decodeURIComponent(value);
+      try {
+        cookies[name15] = decodeURIComponent(value);
+      } catch {
+        cookies[name15] = value;
+      }
     }
   }
   return cookies;
@@ -11874,67 +12150,45 @@ function upload(options) {
   const saveDir = options?.dir;
   return async (req, ctx, next) => {
     const ct = req.headers.get("content-type") ?? "";
-    if (!ct.includes("multipart/form-data")) {
-      return next(req, ctx);
-    }
-    const match = ct.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
-    if (!match) {
-      return Response.json({ error: "Missing boundary" }, { status: 400 });
+    if (!ct.includes("multipart/form-data")) return next(req, ctx);
+    let formData;
+    try {
+      formData = await req.formData();
+    } catch {
+      return Response.json({ error: "Invalid multipart data" }, { status: 400 });
     }
-    const boundary = match[1] ?? match[2];
-    const body = await req.text();
-    const rawParts = body.split(`--${boundary}`).filter((p) => p && !p.startsWith("--") && !p.startsWith("\r\n--"));
     const files = {};
     const fields = {};
-    for (const raw of rawParts) {
-      const trimmed = raw.replace(/^\r?\n/, "");
-      const lines = trimmed.split(/\r?\n/);
-      let i = 0;
-      const headers = {};
-      while (i < lines.length && lines[i].length > 0) {
-        const sep3 = lines[i].indexOf(": ");
-        if (sep3 !== -1) headers[lines[i].slice(0, sep3).toLowerCase()] = lines[i].slice(sep3 + 2);
-        i++;
-      }
-      i++;
-      const bodyValue = lines.slice(i).join("\r\n");
-      const disposition = headers["content-disposition"] ?? "";
-      const nameMatch = disposition.match(/name="([^"]*)"/);
-      if (!nameMatch) continue;
-      const name15 = nameMatch[1];
-      const filenameMatch = disposition.match(/filename="([^"]*)"/);
-      const filename = filenameMatch?.[1];
-      if (filename) {
-        const buf = Buffer.from(bodyValue.replace(/\r?\n$/, ""), "binary");
-        if (options?.allowedTypes) {
-          const mime = headers["content-type"] ?? "application/octet-stream";
-          if (!options.allowedTypes.includes(mime)) {
-            return Response.json({ error: `File type not allowed: ${mime}` }, { status: 415 });
-          }
+    for (const [key, value] of formData) {
+      if (value instanceof File) {
+        if (options?.allowedTypes && !options.allowedTypes.includes(value.type)) {
+          return Response.json({ error: `File type not allowed: ${value.type}` }, { status: 415 });
         }
-        if (options?.maxFileSize && buf.byteLength > options.maxFileSize) {
-          return Response.json({ error: `File too large: ${filename}` }, { status: 413 });
+        if (options?.maxFileSize && value.size > options.maxFileSize) {
+          return Response.json({ error: `File too large: ${value.name}` }, { status: 413 });
         }
+        const buf = Buffer.from(await value.arrayBuffer());
         const uf = {
-          name: filename,
-          type: headers["content-type"] ?? "application/octet-stream",
+          name: value.name,
+          type: value.type,
           size: buf.byteLength,
           buffer: saveDir ? void 0 : buf
         };
         if (saveDir) {
-          const filePath = join2(saveDir, `${randomUUID()}-${filename}`);
+          const safeName = value.name.replace(/[/\\]/g, "");
+          const filePath = join2(saveDir, `${randomUUID()}-${safeName}`);
           await mkdir(saveDir, { recursive: true });
           await writeFile(filePath, buf);
           uf.path = filePath;
         }
-        if (files[name15]) {
-          const existing = files[name15];
-          files[name15] = Array.isArray(existing) ? [...existing, uf] : [existing, uf];
+        if (files[key]) {
+          const existing = files[key];
+          files[key] = Array.isArray(existing) ? [...existing, uf] : [existing, uf];
         } else {
-          files[name15] = uf;
+          files[key] = uf;
         }
       } else {
-        fields[name15] = bodyValue.replace(/\r?\n$/, "");
+        fields[key] = value;
       }
     }
     ctx.parsed = { ...ctx.parsed, files, fields };
@@ -13542,12 +13796,21 @@ function queue(opts) {
     if (!running) return;
     try {
       const now = Date.now();
-      const jobs = await redis2.zrangebyscore(jobKey, 0, now);
-      if (jobs.length > 0) {
-        await redis2.zrem(jobKey, ...jobs);
-      }
-      for (const raw of jobs) {
-        const job = JSON.parse(raw);
+      while (true) {
+        const result = await redis2.zpopmin(jobKey);
+        if (result.length < 2) break;
+        const raw = result[0];
+        const score = parseInt(result[1], 10);
+        if (score > now) {
+          await redis2.zadd(jobKey, score, raw);
+          break;
+        }
+        let job;
+        try {
+          job = JSON.parse(raw);
+        } catch {
+          continue;
+        }
         const handler = handlers.get(job.type);
         if (handler) {
           handler(job).then(() => {
@@ -13555,11 +13818,13 @@ function queue(opts) {
               try {
                 const nextRun = cronNext(job.schedule);
                 const nextJob = { ...job, id: crypto3.randomUUID(), runAt: nextRun, createdAt: Date.now() };
-                redis2.zadd(jobKey, nextRun, JSON.stringify(nextJob));
+                redis2.zadd(jobKey, nextRun, JSON.stringify(nextJob)).catch(() => {
+                });
               } catch {
               }
             }
-          }).catch(() => {
+          }).catch((e) => {
+            console.error("[queue] handler error:", e);
           });
         }
       }
@@ -13844,6 +14109,10 @@ async function getUserTable(sql, tenantId, slug) {
   `;
   return row ?? null;
 }
+function requireAdmin(ctx) {
+  if (ctx.tenant?.role !== "admin") return Response.json({ error: "Forbidden" }, { status: 403 });
+  return null;
+}
 function buildRouter(sql, usersTable) {
   const r = new Router();
   r.post("/sys/tenants", async (req, ctx) => {
@@ -13869,6 +14138,8 @@ function buildRouter(sql, usersTable) {
     return Response.json(rows);
   });
   r.post("/sys/tenants/invite", async (req, ctx) => {
+    const err = requireAdmin(ctx);
+    if (err) return err;
     const { email, role = "member" } = await req.json();
     const [user2] = await sql`
       SELECT id FROM ${sql(usersTable)} WHERE "email" = ${email} LIMIT 1
@@ -13886,6 +14157,8 @@ function buildRouter(sql, usersTable) {
     return Response.json({ ok: true }, { status: 201 });
   });
   r.delete("/sys/tenants/members/:userId", async (req, ctx) => {
+    const err = requireAdmin(ctx);
+    if (err) return err;
     const userId = parseInt(ctx.params.userId, 10);
     await sql`
       DELETE FROM "_tenant_members"
@@ -13894,6 +14167,8 @@ function buildRouter(sql, usersTable) {
     return Response.json({ ok: true });
   });
   r.post("/sys/tables", async (req, ctx) => {
+    const err = requireAdmin(ctx);
+    if (err) return err;
     const body = await req.json();
     const slugErr = validateSlug(body.slug);
     if (slugErr) return Response.json({ error: slugErr }, { status: 400 });
@@ -13932,6 +14207,8 @@ function buildRouter(sql, usersTable) {
     return Response.json(table);
   });
   r.patch("/sys/tables/:slug", async (req, ctx) => {
+    const err = requireAdmin(ctx);
+    if (err) return err;
     const body = await req.json();
     if (!body.fields || !Array.isArray(body.fields)) {
       return Response.json({ error: "fields array required" }, { status: 400 });
@@ -13952,6 +14229,8 @@ function buildRouter(sql, usersTable) {
     return Response.json({ ...table, fields: merged });
   });
   r.delete("/sys/tables/:slug", async (_req, ctx) => {
+    const err = requireAdmin(ctx);
+    if (err) return err;
     await sql.unsafe(dropTableSQL(ctx.tenant.id, ctx.params.slug));
     await sql`
       DELETE FROM "_user_tables"
@@ -24407,15 +24686,19 @@ function createWSHandler(deps) {
                     VALUES (${channel_id}, ${am.member_id}, 'agent', ${result.output})
                   `.then(([r]) => {
                     broadcastToChannel(channel_id, { type: "message", data: r });
+                  }).catch((e) => {
+                    console.error("[messager] agent reply insert failed:", e);
                   });
                 }
-              }).catch(() => {
+              }).catch((e) => {
+                console.error("[messager] agent run failed:", e);
               });
             }
           }
           break;
         }
         case "typing": {
+          if (channel_id) subscribe(ws, userId, channel_id);
           broadcastToChannel(channel_id, {
             type: "typing",
             channel_id,
@@ -24426,6 +24709,7 @@ function createWSHandler(deps) {
         }
         case "read": {
           if (!channel_id || !last_message_id) return;
+          subscribe(ws, userId, channel_id);
           await sql`
             UPDATE "_channel_members"
             SET last_read_id = ${last_message_id}, last_read_at = NOW()
@@ -24570,9 +24854,12 @@ function buildRouter3(deps) {
               VALUES (${channelId}, ${am.member_id}, 'agent', ${result.output})
             `.then(([r2]) => {
               broadcastToChannel(channelId, { type: "message", data: r2 });
+            }).catch((e) => {
+              console.error("[messager] agent reply insert failed:", e);
             });
           }
-        }).catch(() => {
+        }).catch((e) => {
+          console.error("[messager] agent run failed:", e);
         });
       }
     }

package/dist/serve.d.ts CHANGED Viewed

@@ -6,6 +6,7 @@ export interface ServeOptions {
     hostname?: string;
     signal?: AbortSignal;
     websocket?: (req: IncomingMessage, socket: Duplex, head: Buffer) => void;
+    maxBodySize?: number;
 }
 export interface Server {
     stop: () => void;
@@ -13,7 +14,7 @@ export interface Server {
     readonly hostname: string;
     ready: Promise<void>;
 }
-export declare function readBody(req: IncomingMessage): Promise<Buffer>;
+export declare function readBody(req: IncomingMessage, maxSize?: number): Promise<Buffer>;
 export declare function createRequest(req: IncomingMessage, body: Buffer): [Request, Record<string, string>];
 export declare function sendResponse(res: ServerResponse, response: Response): Promise<void>;
 export declare function serve(handler: Handler, options?: ServeOptions): Server;

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "weifuwu",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "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",
+    "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: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"
   },