weifuwu 0.31.1 → 0.32.0

package/dist/middleware/auth.d.ts

@@ -0,0 +1,68 @@
+import type { Middleware, User } from '../types.ts';
+export interface AuthOptions {
+    /**
+     * JWT authentication.
+     *
+     * @example
+     * auth({ jwt: { secret: process.env.JWT_SECRET } })
+     */
+    jwt?: {
+        /** HMAC secret for HS256. */
+        secret: string;
+        /** Cookie name for the token (default: 'token'). */
+        cookie?: string;
+    };
+    /**
+     * Simple session authentication via signed cookie.
+     *
+     * @example
+     * auth({ session: { secret: '...' } })
+     */
+    session?: {
+        /** Secret for HMAC cookie signing. */
+        secret: string;
+        /** Cookie name (default: 'session'). */
+        cookie?: string;
+        /** Load user from session data. */
+        loadUser: (data: Record<string, unknown>) => Promise<User | null> | User | null;
+    };
+    /**
+     * API key authentication via header.
+     *
+     * @example
+     * auth({ apiKey: { header: 'x-api-key', keys: ['sk-xxx'] } })
+     */
+    apiKey?: {
+        /** Header name (default: 'authorization'). */
+        header?: string;
+        /** Prefix to strip (default: 'Bearer '). */
+        prefix?: string;
+        /** Validate an API key → User or null. */
+        validate: (key: string) => Promise<User | null> | User | null;
+    };
+}
+/**
+ * Authentication middleware — injects `ctx.user`.
+ *
+ * Supports JWT (HS256), signed session cookies, and API keys.
+ * When no user is authenticated, requests still proceed —
+ * check `ctx.user` in your handlers to enforce auth.
+ *
+ * @example
+ * ```ts
+ * // JWT
+ * app.use(auth({ jwt: { secret: 'my-secret' } }))
+ *
+ * // Session cookie
+ * app.use(auth({
+ *   session: {
+ *     secret: '...',
+ *     loadUser: async (data) => db.findUser(data.userId),
+ *   },
+ * }))
+ *
+ * // API key
+ * app.use(auth({ apiKey: { validate: async (key) => db.findByApiKey(key) } }))
+ * ```
+ */
+export declare function auth(opts: AuthOptions): Middleware;

package/dist/middleware/esbuild-dev.d.ts

@@ -0,0 +1,69 @@
+/**
+ * esbuildDev — on-the-fly esbuild compilation middleware for development.
+ *
+ * Compiles TypeScript/JSX/TSX client bundles in memory on first request,
+ * caches results based on source file mtime, and serves with ETag support.
+ *
+ * @example
+ * ```ts
+ * import { esbuildDev } from 'weifuwu'
+ *
+ * app.use(esbuildDev({
+ *   entries: {
+ *     '/assets/vendor.js': { entry: './client/vendor.ts', bundle: true },
+ *     '/assets/client.js': { entry: './client/client.ts', external: ['react', 'react-dom/client'] },
+ *   },
+ *   importmap: true,  // auto-generate importmap script
+ * }))
+ * ```
+ */
+import type { Middleware, Context } from '../types.ts';
+export interface EsbuildDevEntry {
+    /** Source entry point relative to cwd or absolute. Ignored when `clientRouter` is set. */
+    entry?: string;
+    /**
+     * Auto-generate a client entry from route config — eliminates client.ts.
+     * The generated entry imports routes + layout, calls createBrowserRouter().
+     */
+    clientRouter?: {
+        /** Path to the shared routes file (relative to cwd). Overridden by `pages`. */
+        routes?: string;
+        /** Inline page definitions — alternative to a separate routes.ts file. */
+        pages?: Record<string, string>;
+        /** Layout component import path (relative to cwd). */
+        layout: string;
+        /** Fallback 404 component import path (relative to cwd). */
+        fallback?: string;
+    };
+    /** Bundle all dependencies (default: true). */
+    bundle?: boolean;
+    /** Packages to leave external (not bundled). */
+    external?: string[];
+    /** Minify output (default: true). */
+    minify?: boolean;
+    /** Target platform (default: 'browser'). */
+    platform?: 'browser' | 'neutral' | 'node';
+    /** Output format (default: 'esm'). */
+    format?: 'esm' | 'iife';
+    /** Generate sourcemaps (default: false). */
+    sourcemap?: boolean | 'inline' | 'external' | 'linked';
+    /** Enable code splitting for dynamic import() (default: false). */
+    splitting?: boolean;
+    /** Compile-time constant substitution. */
+    define?: Record<string, string>;
+    /** Custom loaders per file extension. */
+    loader?: Record<string, string>;
+}
+export interface EsbuildDevOptions {
+    /** Map of URL path → entry config (string shorthand for { entry }). */
+    entries: Record<string, EsbuildDevEntry | string>;
+    /** Auto-generate a /assets/importmap script that maps react → vendor */
+    importmap?: boolean;
+    /** Importmap overrides (e.g. { 'react': '/assets/custom-vendor.js' }). */
+    importmapOverrides?: Record<string, string>;
+    /** Cache strategy: 'memory' keeps compiled results, 'none' recompiles every request. */
+    cache?: 'memory' | 'none';
+    /** Custom HTML template for build errors (receives escaped error text). */
+    errorTemplate?: (errors: string) => string;
+}
+export declare function esbuildDev(opts: EsbuildDevOptions): Middleware<Context, Context>;

package/dist/middleware/esbuild-dev.js

@@ -0,0 +1,335 @@
+// src/middleware/esbuild-dev.ts
+import { resolve, relative, dirname } from "node:path";
+import { stat, readFile, realpath } from "node:fs/promises";
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function defaultErrorTemplate(errors) {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Build Error</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body { font-family: system-ui; background: #1a1a2e; color: #e0e0e0; padding: 2rem; }
+    .overlay { position: fixed; inset: 0; display: flex; align-items: center; justify-content: center; }
+    .card { background: #16213e; border: 1px solid #e74c3c; border-radius: 12px; padding: 2rem; max-width: 800px; width: 100%; box-shadow: 0 8px 32px rgba(0,0,0,0.4); }
+    h1 { color: #e74c3c; font-size: 1.5rem; margin-bottom: 1rem; display: flex; align-items: center; gap: 0.5rem; }
+    pre { background: #0f0f23; padding: 1.5rem; border-radius: 8px; overflow: auto; font-size: 0.85rem; line-height: 1.6; white-space: pre-wrap; word-break: break-word; }
+  </style>
+</head>
+<body>
+  <div class="overlay">
+    <div class="card">
+      <h1>\u26A0 esbuild Build Error</h1>
+      <pre>${escapeHtml(errors)}</pre>
+    </div>
+  </div>
+</body>
+</html>`;
+}
+async function collectDeps(entryPath) {
+  const files = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [entryPath];
+  while (queue.length > 0) {
+    const p = queue.shift();
+    try {
+      const real = await realpath(p);
+      if (visited.has(real)) continue;
+      visited.add(real);
+      const s = await stat(real);
+      files.set(real, s.mtimeMs);
+    } catch {
+      continue;
+    }
+    try {
+      const content = await readFile(p, "utf-8");
+      const importRe = /from\s+['"]([^'"]+)['"]|import\s+['"]([^'"]+)['"]/g;
+      let m;
+      while ((m = importRe.exec(content)) !== null) {
+        const spec = m[1] ?? m[2];
+        if (spec.startsWith(".") || spec.startsWith("/")) {
+          const dir = dirname(p);
+          const resolved = resolve(dir, spec);
+          for (const ext of ["", ".ts", ".tsx", ".js", ".jsx", ".mjs", "/index.ts", "/index.tsx", "/index.js"]) {
+            const candidate = resolved + ext;
+            if (!visited.has(candidate)) {
+              queue.push(candidate);
+              break;
+            }
+            break;
+          }
+          queue.push(resolved);
+        }
+      }
+    } catch {
+    }
+  }
+  return files;
+}
+function esbuildDev(opts) {
+  const cache = opts.cache ?? "memory";
+  const importmap = opts.importmap ?? false;
+  const importmapOverrides = opts.importmapOverrides ?? {};
+  const errorTemplate = opts.errorTemplate ?? defaultErrorTemplate;
+  const entries = Object.entries(opts.entries).map(([p, e]) => {
+    const path = p.startsWith("/") ? p : "/" + p;
+    const config = typeof e === "string" ? { entry: e } : e;
+    return { path, config };
+  });
+  const cacheStore = /* @__PURE__ */ new Map();
+  const chunkMap = /* @__PURE__ */ new Map();
+  let esbuild_ = null;
+  let esbuildLoadError = null;
+  async function getEsbuild() {
+    if (esbuild_) return esbuild_;
+    try {
+      esbuild_ = await import("esbuild");
+      return esbuild_;
+    } catch (err) {
+      esbuildLoadError = `esbuild is not installed. Run: npm install -D esbuild
+
+${String(err)}`;
+      throw new Error(esbuildLoadError, { cause: err });
+    }
+  }
+  let importmapScript = null;
+  function buildImportmap() {
+    const mappings = {};
+    Object.assign(mappings, importmapOverrides);
+    for (const { path, config } of entries) {
+      const entryName = path.split("/").pop() ?? "";
+      if (entryName.includes("vendor") || config.external && config.external.length === 0 || !config.external && config.bundle !== false) {
+        if (!mappings["react"]) mappings["react"] = path;
+        if (!mappings["react/jsx-runtime"]) mappings["react/jsx-runtime"] = path;
+        if (!mappings["react-dom/client"]) mappings["react-dom/client"] = path;
+        if (!mappings["react-dom"]) mappings["react-dom"] = path;
+      }
+    }
+    const json = JSON.stringify({ imports: mappings });
+    return `<script type="importmap">${json}</script>`;
+  }
+  async function compile(entry) {
+    const esbuild = await getEsbuild();
+    const isClientRouter = !!entry.clientRouter;
+    let entryAbs;
+    let buildOpts;
+    if (isClientRouter) {
+      const cr = entry.clientRouter;
+      const virtualModule = "weifuwu:client-entry";
+      entryAbs = virtualModule;
+      const layoutImport = `import * as _layout from '${cr.layout}'
+const _lx = Object.entries(_layout).filter(([,v]) => typeof v === 'function')
+const Layout = _layout.default || (_lx[0]?.[1])`;
+      let routesCode;
+      if (cr.pages) {
+        const entries2 = Object.entries(cr.pages).map(
+          ([path, component]) => `  '${path}': () => import('${component}'),`
+        );
+        routesCode = `const routes = {
+${entries2.join("\n")}
+}`;
+      } else if (cr.routes) {
+        routesCode = `import { routes } from '${cr.routes}'`;
+      } else {
+        routesCode = "const routes = {}";
+      }
+      const fallbackLine = cr.fallback ? `const fallback = () => import('${cr.fallback}')` : "";
+      const fallbackOpt = cr.fallback ? "  fallback," : "";
+      const generatedCode = [
+        `import { createBrowserRouter } from 'weifuwu/react/client'`,
+        layoutImport,
+        routesCode,
+        fallbackLine,
+        "",
+        "createBrowserRouter({",
+        "  layout: Layout,",
+        "  routes,",
+        fallbackOpt,
+        "})"
+      ].filter(Boolean).join("\n");
+      buildOpts = {
+        entryPoints: [virtualModule],
+        bundle: entry.bundle ?? true,
+        external: entry.external ?? [],
+        minify: entry.minify ?? true,
+        platform: entry.platform ?? "browser",
+        format: entry.format ?? "esm",
+        sourcemap: entry.sourcemap ?? false,
+        splitting: entry.splitting ?? false,
+        ...entry.splitting ? { outdir: resolve(".weifuwu-esbuild-out") } : {},
+        define: entry.define,
+        loader: entry.loader,
+        write: false,
+        logLevel: "silent",
+        plugins: [{
+          name: "weifuwu-client-router",
+          setup(build) {
+            build.onResolve({ filter: new RegExp(`^${virtualModule.replace(/:/g, "\\:")}$`) }, () => ({
+              path: virtualModule,
+              namespace: "weifuwu-client"
+            }));
+            build.onLoad({ filter: /.*/, namespace: "weifuwu-client" }, () => ({
+              contents: generatedCode,
+              loader: "ts",
+              resolveDir: process.cwd()
+            }));
+          }
+        }]
+      };
+    } else {
+      entryAbs = resolve(entry.entry);
+      buildOpts = {
+        entryPoints: [entryAbs],
+        bundle: entry.bundle ?? true,
+        external: entry.external ?? [],
+        minify: entry.minify ?? true,
+        platform: entry.platform ?? "browser",
+        format: entry.format ?? "esm",
+        sourcemap: entry.sourcemap ?? false,
+        splitting: entry.splitting ?? false,
+        ...entry.splitting ? { outdir: dirname(entryAbs) } : {},
+        define: entry.define,
+        loader: entry.loader,
+        write: false,
+        logLevel: "silent"
+      };
+    }
+    const result = await esbuild.build(buildOpts);
+    const msgs = [];
+    for (const w of result.warnings) {
+      const loc = w.location ? ` at ${relative(".", w.location.file ?? "")}:${w.location.line}:${w.location.column}` : "";
+      msgs.push(`[warn] ${w.text}${loc}`);
+    }
+    for (const e of result.errors) {
+      const loc = e.location ? ` at ${relative(".", e.location.file ?? "")}:${e.location.line}:${e.location.column}` : "";
+      msgs.push(`[error] ${e.text}${loc}`);
+    }
+    if (result.errors.length > 0) {
+      throw new Error(msgs.join("\n"));
+    }
+    const outputFiles = result.outputFiles;
+    const entryFile = outputFiles.find((f) => f.path === entryAbs) ?? outputFiles[0];
+    const code = entryFile?.text ?? "";
+    let chunks;
+    if (outputFiles.length > 1) {
+      chunks = /* @__PURE__ */ new Map();
+      for (const f of outputFiles) {
+        if (f === entryFile) continue;
+        const chunkName = f.path.split("/").pop() ?? f.path;
+        chunks.set(chunkName, { code: f.text, etag: `"esbuild-${hashCode(f.text)}"` });
+      }
+    }
+    const etag = `"esbuild-${hashCode(code)}"`;
+    if (msgs.length > 0) {
+      console.error("[esbuildDev]", msgs.join("\n"));
+    }
+    return { code, etag, chunks };
+  }
+  function isCacheValid(cached) {
+    return Promise.all(
+      [...cached.files].map(async ([file, mtime]) => {
+        try {
+          const s = await stat(file);
+          return s.mtimeMs === mtime;
+        } catch {
+          return false;
+        }
+      })
+    ).then((results) => results.every(Boolean));
+  }
+  return async (req, ctx, next) => {
+    const url = new URL(req.url);
+    const pathname = url.pathname;
+    if (importmap && pathname === "/assets/importmap") {
+      if (!importmapScript) importmapScript = buildImportmap();
+      return new Response(importmapScript, {
+        headers: {
+          "Content-Type": "application/javascript; charset=utf-8",
+          "Cache-Control": "no-cache"
+        }
+      });
+    }
+    const matched = entries.find((e) => e.path === pathname);
+    const chunkName = pathname.split("/").pop() ?? "";
+    const chunkOwner = chunkMap.get(chunkName);
+    if (!matched && !chunkOwner) return next(req, ctx);
+    if (!matched && chunkOwner) {
+      const ownerCache = cacheStore.get(chunkOwner);
+      const chunk = ownerCache?.chunks?.get(chunkName);
+      if (chunk) {
+        if (req.headers.get("if-none-match") === chunk.etag) {
+          return new Response(null, { status: 304 });
+        }
+        return new Response(chunk.code, {
+          headers: {
+            "Content-Type": "text/javascript; charset=utf-8",
+            ETag: chunk.etag,
+            "Cache-Control": "no-cache"
+          }
+        });
+      }
+      return next(req, ctx);
+    }
+    const { config } = matched;
+    try {
+      if (cache === "memory") {
+        const cached = cacheStore.get(pathname);
+        if (cached) {
+          const valid = await isCacheValid(cached);
+          if (valid) {
+            if (req.headers.get("if-none-match") === cached.etag) {
+              return new Response(null, { status: 304 });
+            }
+            return new Response(cached.code, {
+              headers: {
+                "Content-Type": "text/javascript; charset=utf-8",
+                ETag: cached.etag,
+                "Cache-Control": "no-cache"
+              }
+            });
+          }
+          for (const [cn] of cached.chunks ?? []) chunkMap.delete(cn);
+          cacheStore.delete(pathname);
+        }
+      }
+      const { code, etag, chunks } = await compile(config);
+      const depEntry = config.clientRouter?.routes ?? (config.clientRouter?.pages ? Object.values(config.clientRouter.pages)[0] : void 0) ?? config.entry;
+      const deps = await collectDeps(resolve(depEntry));
+      if (cache === "memory") {
+        cacheStore.set(pathname, { code, etag, files: deps, chunks });
+        if (chunks) {
+          for (const [cn] of chunks) chunkMap.set(cn, pathname);
+        }
+      }
+      return new Response(code, {
+        headers: {
+          "Content-Type": "text/javascript; charset=utf-8",
+          ETag: etag,
+          "Cache-Control": "no-cache"
+        }
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const html = errorTemplate(message);
+      return new Response(html, {
+        status: 500,
+        headers: { "Content-Type": "text/html; charset=utf-8" }
+      });
+    }
+  };
+}
+function hashCode(s) {
+  let hash = 0;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s.charCodeAt(i);
+    hash = (hash << 5) - hash + ch;
+    hash |= 0;
+  }
+  return Math.abs(hash).toString(36);
+}
+export {
+  esbuildDev
+};

package/dist/middleware/sandbox.d.ts

@@ -0,0 +1,52 @@
+import type { Middleware } from '../types.ts';
+declare module '../types.ts' {
+    interface Context {
+        /** Filesystem sandbox for agent operations. Injected by sandbox(). */
+        sandbox: Sandbox;
+    }
+}
+export interface SandboxOptions {
+    /** Root directory for all workspaces (default: '/tmp/weifuwu-sandboxes'). */
+    baseDir?: string;
+    /** Default timeout for exec() in ms (default: 30000). */
+    timeout?: number;
+    /** Isolate workspaces by a ctx field. If 'user', uses ctx.user.id. */
+    isolateBy?: 'user';
+}
+export interface ExecResult {
+    stdout: string;
+    stderr: string;
+}
+export interface Sandbox {
+    /** The workspace directory for the current request. */
+    workDir: string;
+    /** Read a file inside the workspace. */
+    readFile(path: string): Promise<string>;
+    /** Write a file inside the workspace. Creates parent directories. */
+    writeFile(path: string, content: string): Promise<void>;
+    /** Execute a command inside the workspace. */
+    exec(cmd: string, opts?: {
+        timeout?: number;
+        cwd?: string;
+    }): Promise<ExecResult>;
+    /** Grep for a pattern inside the workspace. */
+    grep(pattern: string): Promise<string>;
+    /** Destroy the workspace (called when the session ends). */
+    destroy(): Promise<void>;
+}
+/**
+ * Filesystem sandbox middleware.
+ *
+ * Each request gets an isolated workspace directory. File and exec
+ * operations are restricted to the workspace — path escapes are rejected.
+ *
+ * @example
+ * ```ts
+ * app.use(sandbox({ baseDir: '/tmp/workspaces', isolateBy: 'user' }))
+ *
+ * // In a handler:
+ * await ctx.sandbox.writeFile('hello.txt', 'world')
+ * const content = await ctx.sandbox.readFile('hello.txt')
+ * ```
+ */
+export declare function sandbox(opts?: SandboxOptions): Middleware;

package/dist/middleware/tailwind-dev.d.ts

@@ -0,0 +1,43 @@
+/**
+ * tailwindDev — on-the-fly Tailwind CSS v4 compilation for development.
+ *
+ * Compiles a CSS entry file (with @import "tailwindcss") and scans content
+ * files for class names, generating optimized CSS in memory on first request.
+ *
+ * Caches results based on source file mtime and serves with ETag support.
+ *
+ * @example
+ * ```ts
+ * import { tailwindDev } from 'weifuwu'
+ *
+ * app.use(tailwindDev({
+ *   '/assets/tailwind.css': {
+ *     entry: './styles/input.css',
+ *     content: ['./components/**\/*.ts', './pages/**\/*.ts'],
+ *   },
+ * }))
+ * ```
+ *
+ * CSS entry example (styles/input.css):
+ * ```css
+ * @import "tailwindcss";
+ * ```
+ */
+import type { Middleware, Context } from '../types.ts';
+export interface TailwindDevEntry {
+    /** Path to CSS entry file (with @import "tailwindcss"). */
+    entry: string;
+    /** Glob patterns for content files to scan for class names. */
+    content?: string[];
+    /** Minify output (default: false in dev). */
+    minify?: boolean;
+}
+export interface TailwindDevOptions {
+    /** Map of URL path → entry config (string shorthand for { entry }). */
+    entries: Record<string, TailwindDevEntry | string>;
+    /** Cache strategy: 'memory' keeps compiled results, 'none' recompiles every request. */
+    cache?: 'memory' | 'none';
+    /** Custom HTML template for build errors (receives escaped error text). */
+    errorTemplate?: (errors: string) => string;
+}
+export declare function tailwindDev(opts: TailwindDevOptions): Middleware<Context, Context>;