weifuwu 0.19.4 → 0.19.6

package/dist/index.js

@@ -376,13 +376,13 @@ var Router = class _Router {
             const mw = match.middlewares[index++];
             return mw(innerReq, ctx2, dispatch);
           }
-          return await new Promise((resolve14) => {
+          return await new Promise((resolve15) => {
             try {
               upgradeSocket(router.wss, req, socket, head, match.handler, ctx2);
-              resolve14(new Response(null, { status: 101 }));
+              resolve15(new Response(null, { status: 101 }));
             } catch {
               socket.destroy();
-              resolve14(new Response("WebSocket upgrade failed", { status: 500 }));
+              resolve15(new Response("WebSocket upgrade failed", { status: 500 }));
             }
           });
         };
@@ -2845,7 +2845,7 @@ function createHub(opts) {
       }
     });
   }
-  function join8(key, ws) {
+  function join9(key, ws) {
     if (!channels.has(key)) {
       channels.set(key, /* @__PURE__ */ new Set());
       redisSub?.subscribe(`${prefix}${key}`);
@@ -2886,7 +2886,7 @@ function createHub(opts) {
       await redisSub.quit();
     }
   }
-  return { join: join8, leave, broadcast, close };
+  return { join: join9, leave, broadcast, close };
 }
 
 // queue/index.ts
@@ -4584,16 +4584,8 @@ import path from "node:path";
 
 // deploy/gateway.ts
 import WebSocket2, { WebSocketServer as WebSocketServer2 } from "ws";
-function isBareDomain(host, domain) {
-  return host === domain || host === `www.${domain}`;
-}
 function matchApp(config, getPort, host, pathname) {
-  for (const [name, ac] of Object.entries(config.apps)) {
-    if (ac.subdomain && host === `${ac.subdomain}.${config.domain}`) {
-      const port = getPort(name);
-      if (port) return { name, port };
-    }
-  }
+  const domain = config.domain || "localhost";
   const pathApps = Object.entries(config.apps).filter(([, ac]) => ac.path).sort(([, a], [, b]) => (b.path?.length ?? 0) - (a.path?.length ?? 0));
   for (const [name, ac] of pathApps) {
     if (ac.path && pathname.startsWith(ac.path)) {
@@ -4601,7 +4593,16 @@ function matchApp(config, getPort, host, pathname) {
       if (port) return { name, port, stripPath: ac.path };
     }
   }
-  if (config.defaultApp && isBareDomain(host, config.domain)) {
+  for (const [name, ac] of Object.entries(config.apps)) {
+    if (ac.path) continue;
+    const hostMatch = host === `${name}.${domain}` || host === name;
+    const pathMatch = pathname === `/${name}` || pathname.startsWith(`/${name}/`);
+    if (hostMatch || pathMatch) {
+      const port = getPort(name);
+      if (port) return { name, port };
+    }
+  }
+  if (config.defaultApp) {
     const port = getPort(config.defaultApp);
     if (port) return { name: config.defaultApp, port };
   }
@@ -4696,14 +4697,14 @@ function forkApp(opts) {
   return { child, port: opts.port };
 }
 function stopProcess(mp, timeout = 1e4) {
-  return new Promise((resolve14) => {
+  return new Promise((resolve15) => {
     const timer = setTimeout(() => {
       mp.child.kill("SIGKILL");
-      resolve14();
+      resolve15();
     }, timeout);
     mp.child.on("exit", () => {
       clearTimeout(timer);
-      resolve14();
+      resolve15();
     });
     mp.child.kill("SIGTERM");
   });
@@ -4814,83 +4815,36 @@ function createManager(config, apps, manager) {
       }
     });
   });
-  router.post("/reload", auth2, async () => {
-    try {
-      await manager.reloadConfig();
-      return Response.json({ success: true });
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return Response.json({ error: msg }, { status: 400 });
-    }
-  });
-  router.post("/webhook", async (req) => {
-    const rawBody = await req.text();
-    if (config.webhookSecret) {
-      const sig = req.headers.get("x-hub-signature-256") ?? "";
-      const expected = `sha256=${crypto5.createHmac("sha256", config.webhookSecret).update(rawBody).digest("hex")}`;
-      const sigBuf = Buffer.from(sig);
-      const expectedBuf = Buffer.from(expected);
-      if (sigBuf.length !== expectedBuf.length || !crypto5.timingSafeEqual(sigBuf, expectedBuf)) {
-        return Response.json({ error: "invalid signature" }, { status: 401 });
-      }
-    }
-    let payload;
-    try {
-      payload = JSON.parse(rawBody);
-    } catch {
-      payload = {};
-    }
-    const repoUrl = payload?.repository?.clone_url ?? payload?.repository?.html_url ?? "";
-    if (!repoUrl) return Response.json({ deployed: [] });
-    const deployed = [];
-    for (const [name] of apps) {
-      const ac = apps.get(name)?.config;
-      if (!ac) continue;
-      const repoNorm = ac.repo.replace(/\.git$/, "").replace(/https:\/\/[^@]+@/, "https://");
-      const payloadNorm = repoUrl.replace(/\.git$/, "").replace(/https:\/\/[^@]+@/, "https://");
-      if (payloadNorm.includes(repoNorm)) {
-        await manager.deployApp(name);
-        deployed.push(name);
-      }
-    }
-    return Response.json({ deployed });
-  });
   return router;
 }
 
 // deploy/config.ts
 function defineConfig(config) {
-  if (!config.domain) throw new Error("deploy: domain is required");
-  if (!config.apps || Object.keys(config.apps).length === 0) {
-    throw new Error("deploy: at least one app is required");
-  }
-  for (const [name, app] of Object.entries(config.apps)) {
-    if (!app.repo) throw new Error(`deploy: app "${name}" has no repo`);
-    if (!app.entry) throw new Error(`deploy: app "${name}" has no entry`);
-    if (!app.port) throw new Error(`deploy: app "${name}" has no port`);
+  const domain = config.domain || "localhost";
+  const port = config.port ?? 3e3;
+  let nextPort = 3001;
+  for (const [name, ac] of Object.entries(config.apps)) {
+    ac.dir ??= name;
+    ac.entry ??= "index.ts";
+    ac.port ??= nextPort++;
+    if (!ac.path && domain === "localhost") {
+      ac.path = `/${name}`;
+    }
   }
-  return {
-    port: config.port ?? 80,
-    appsDir: config.appsDir ?? "/opt/weifuwu/apps",
-    ...config
-  };
+  return { ...config, domain, port };
 }
 
 // deploy/index.ts
 async function deploy(config) {
-  const appsDir = config.appsDir ?? "/opt/weifuwu/apps";
   const apps = /* @__PURE__ */ new Map();
   let httpServer;
-  if (!fs.existsSync(appsDir)) {
-    fs.mkdirSync(appsDir, { recursive: true });
-  }
-  async function forkAndCheck(cwd, entry, port, env, onLog, healthEndpoint) {
+  async function forkAndCheck(name, cwd, entry, port, env, onLog, healthEndpoint) {
     try {
       const mp = forkApp({ cwd, entry, port, env, onLog });
-      onLog(`[deploy] forked pid ${mp.child.pid} on port ${mp.port}`);
+      onLog(`[deploy] forked ${name} (pid ${mp.child.pid}) on port ${mp.port}`);
       const healthy = await healthCheck(port, healthEndpoint ?? "/");
-      if (healthy) onLog("[deploy] health check passed");
-      else onLog("[deploy] health check failed");
+      if (healthy) onLog(`[deploy] health check passed`);
+      else onLog(`[deploy] health check failed`);
       return mp;
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -4912,49 +4866,15 @@ async function deploy(config) {
       clearTimeout(old.restartTimer);
       old.restartTimer = void 0;
     }
-    const appDir = path.join(appsDir, name);
+    const appDir = path.resolve(ac.dir);
     const logs = [];
     const log = (line) => {
       logs.push(line);
       if (logs.length > 1e3) logs.splice(0, logs.length - 1e3);
     };
-    try {
-      if (typeof ac.repo !== "string" || !/^https?:\/\/[^\s"']+\/[^\s"']+/.test(ac.repo) && !/^git@[^\s"']+:[^\s"']+/.test(ac.repo)) {
-        throw new Error(`Invalid repo URL: ${ac.repo}`);
-      }
-      if (ac.branch && typeof ac.branch === "string" && !/^[\w.\-/]+$/.test(ac.branch)) {
-        throw new Error(`Invalid branch name: ${ac.branch}`);
-      }
-      if (fs.existsSync(path.join(appDir, ".git"))) {
-        execSync("git pull", { cwd: appDir, stdio: "pipe", timeout: 12e4 });
-        log("[deploy] git pull done");
-      } else {
-        if (fs.existsSync(appDir)) {
-          fs.rmSync(appDir, { recursive: true });
-        }
-        execSync(`git clone --depth=1 ${ac.repo} ${appDir}`, { stdio: "pipe", timeout: 12e4 });
-        log("[deploy] git clone done");
-        if (ac.branch) {
-          execSync(`git checkout ${ac.branch}`, { cwd: appDir, stdio: "pipe", timeout: 3e4 });
-          log(`[deploy] switched to branch ${ac.branch}`);
-        }
-      }
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      setAppRuntime(name, ac, logs, { status: "error", port: ac.port, error: msg });
-      log(`[deploy] git error: ${msg}`);
-      if (old?.process) {
-        apps.set(name, old);
-      }
-      return;
-    }
-    try {
-      execSync("npm install", { cwd: appDir, stdio: "pipe", timeout: 12e4 });
-      log("[deploy] npm install done");
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      setAppRuntime(name, ac, logs, { status: "error", port: ac.port, error: msg });
-      log(`[deploy] npm install error: ${msg}`);
+    if (!fs.existsSync(appDir)) {
+      setAppRuntime(name, ac, logs, { status: "error", error: `dir not found: ${appDir}` });
+      log(`[deploy] dir not found: ${appDir}`);
       if (old?.process) apps.set(name, old);
       return;
     }
@@ -4978,7 +4898,7 @@ async function deploy(config) {
     if (ac.ports && old?.process) {
       targetPort = old.currentPort === ac.ports[0] ? ac.ports[1] : ac.ports[0];
     }
-    const mp = await forkAndCheck(appDir, ac.entry, targetPort, ac.env, log, ac.healthEndpoint);
+    const mp = await forkAndCheck(name, appDir, ac.entry, targetPort, ac.env, log, ac.healthEndpoint);
     if (!mp) {
       log("[deploy] new process failed to start, keeping old running");
       if (old?.process) apps.set(name, old);
@@ -4989,7 +4909,13 @@ async function deploy(config) {
     }
     const runtime = {
       config: ac,
-      status: { name, status: "running", port: targetPort, subdomain: ac.subdomain, path: ac.path, pid: mp.child.pid ?? void 0 },
+      status: {
+        name,
+        status: "running",
+        port: targetPort,
+        path: ac.path,
+        pid: mp.child.pid ?? void 0
+      },
       logs,
       process: mp.child,
       currentPort: targetPort,
@@ -5023,7 +4949,7 @@ async function deploy(config) {
       status: { name, ...overrides },
       logs,
       process: null,
-      currentPort: overrides.port ?? ac.port,
+      currentPort: overrides.port ?? ac.port ?? 0,
       startedAt: null,
       restartCount: 0,
       restartTimer: void 0
@@ -5052,14 +4978,10 @@ async function deploy(config) {
     }
     return gw.handler(req, ctx);
   };
-  if (config.ssl) {
-    ensureCertificates(config);
-  }
   httpServer = serve(fullHandler, {
     port: config.port,
     websocket: gw.wsHandler
   });
-  const portSuffix = config.port !== 80 ? `:${config.port}` : "";
   return {
     close: async () => {
       for (const [, app] of apps) {
@@ -5071,7 +4993,7 @@ async function deploy(config) {
       httpServer?.stop();
     },
     ready: httpServer.ready,
-    url: `http://${config.domain}${portSuffix}`,
+    url: `http://localhost:${config.port}/`,
     apps: {
       list: () => Array.from(apps.values()).map((a) => a.status),
       status: (name) => apps.get(name)?.status,
@@ -5096,44 +5018,12 @@ async function deploy(config) {
     }
   };
 }
-function ensureCertificates(config) {
-  const { domain, ssl } = config;
-  if (!ssl) return;
-  const certDir = "/etc/weifuwu/ssl";
-  const certPath = path.join(certDir, `${domain}.pem`);
-  const keyPath = path.join(certDir, `${domain}-key.pem`);
-  if (fs.existsSync(certPath) && fs.existsSync(keyPath)) return;
-  if (!fs.existsSync(certDir)) {
-    fs.mkdirSync(certDir, { recursive: true });
-  }
-  const acmeHome = path.join(certDir, ".acme.sh");
-  try {
-    execSync("which acme.sh", { stdio: "pipe" });
-  } catch {
-    execSync(
-      `curl -s https://get.acme.sh | sh -s email=${ssl.email}`,
-      { stdio: "pipe", timeout: 6e4 }
-    );
-  }
-  const subdomains = Object.values(config.apps).filter((a) => a.subdomain).map((a) => `${a.subdomain}.${domain}`).join(",");
-  const allDomains = subdomains ? `${domain},${subdomains}` : domain;
-  const acmeSh = path.join(acmeHome, "acme.sh");
-  const staging = ssl.staging ? " --staging" : "";
-  execSync(
-    `${acmeSh} --issue -d ${allDomains} --standalone${staging} --cert-file ${certPath} --key-file ${keyPath}`,
-    { stdio: "pipe", timeout: 12e4 }
-  );
-  execSync(
-    `${acmeSh} --install-cronjob`,
-    { stdio: "pipe", timeout: 3e4 }
-  );
-}
 
 // opencode/client.ts
 import { createOpenAI as createOpenAI3 } from "@ai-sdk/openai";
 
 // opencode/rest.ts
-import { join as join5 } from "node:path";
+import { join as join7 } from "node:path";
 
 // ssr.ts
 import { createElement } from "react";
@@ -5341,7 +5231,8 @@ function buildHeadPayload(opts) {
 `;
   }
   if (compiledTailwindCss) {
-    result += `<link rel="stylesheet" href="${base}/__wfw/style.css" />
+    const cssUrl = ctx.tailwindCssUrl || "/__wfw/style.css";
+    result += `<link rel="stylesheet" href="${cssUrl}" />
 `;
   }
   const localeData = ctx.parsed?.__localeData ?? globalThis.__LOCALE_DATA__;
@@ -5506,7 +5397,7 @@ async function buildClientBundle(entryPath, layoutPaths) {
       jsxImportSource: "react",
       banner: { js: "self.process={env:{}};" },
       loader: { ".node": "empty" },
-      external: isDev ? ["react", "react-dom", "react-dom/client", "react/jsx-runtime", "weifuwu/react"] : void 0,
+      external: isDev ? ["react", "react-dom", "react-dom/client", "react/jsx-runtime", "weifuwu", "weifuwu/react"] : void 0,
       write: false,
       minify: !isDev
     });
@@ -5600,7 +5491,12 @@ function ssr(path2) {
   return r;
 }
 
+// root-layout.ts
+import { existsSync as existsSync5 } from "node:fs";
+import { join as join5, resolve as resolve7 } from "node:path";
+
 // tailwind.ts
+import { createHash as createHash4 } from "node:crypto";
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync } from "node:fs";
 import { join as join3, relative, resolve as resolve5 } from "node:path";
 var extraSources = /* @__PURE__ */ new Set();
@@ -5611,16 +5507,21 @@ function tailwind(dir) {
   const r = new Router();
   r.use(async (req, ctx, next) => {
     if (!cssCache.has(cssPath)) {
-      cssCache.set(cssPath, await compileTailwindCss(cssPath, cssDir));
+      await compileTailwindCss(cssPath, cssDir);
     }
-    ctx.compiledTailwindCss = cssCache.get(cssPath);
+    const entry = cssCache.get(cssPath);
+    ctx.compiledTailwindCss = entry.css;
+    const base = (ctx.mountPath || "").replace(/\/$/, "");
+    ctx.tailwindCssUrl = base ? `${base}/__wfw/style/${entry.hash}.css` : `/__wfw/style/${entry.hash}.css`;
     return next(req, ctx);
   });
-  r.get("/__wfw/style.css", async (req, ctx) => {
+  r.get("/__wfw/style/:hash.css", async (req, ctx) => {
     if (!cssCache.has(cssPath)) {
-      cssCache.set(cssPath, await compileTailwindCss(cssPath, cssDir));
+      await compileTailwindCss(cssPath, cssDir);
     }
-    return new Response(cssCache.get(cssPath) || "", {
+    const entry = cssCache.get(cssPath);
+    if (!entry) return new Response("", { status: 404 });
+    return new Response(entry.css, {
       headers: { "content-type": "text/css; charset=utf-8" }
     });
   });
@@ -5643,7 +5544,8 @@ ${src}`;
 ${src}`;
     }
     const result = await postcss([tailwindPlugin()]).process(src, { from: cssPath });
-    cssCache.set(cssPath, result.css);
+    const hash = createHash4("md5").update(result.css).digest("hex").slice(0, 8);
+    cssCache.set(cssPath, { css: result.css, hash });
     return result.css;
   } catch (err) {
     console.warn("Tailwind CSS processing failed:", err.message);
@@ -5651,20 +5553,144 @@ ${src}`;
   }
 }
 
-// layout.ts
-function layout(path2) {
-  return async (req, ctx, next) => {
-    const mod = await compile(path2);
-    const Component = mod.default;
-    if (!Component) throw new Error(`Layout ${path2} has no default export`);
-    ctx.layoutStack = [...ctx.layoutStack || [], { path: path2, component: Component }];
-    return next(req, ctx);
+// live.ts
+import chokidar from "chokidar";
+import { existsSync as existsSync4 } from "node:fs";
+import { join as join4, resolve as resolve6 } from "node:path";
+var clients = /* @__PURE__ */ new Set();
+var hotBundleCache = /* @__PURE__ */ new Map();
+var hotKeys = [];
+var MAX_HOT = 10;
+function setHot(hash, code) {
+  if (!hotBundleCache.has(hash)) {
+    hotKeys.push(hash);
+    if (hotKeys.length > MAX_HOT) {
+      const old = hotKeys.shift();
+      hotBundleCache.delete(old);
+    }
+  }
+  hotBundleCache.set(hash, code);
+}
+function broadcastReload() {
+  for (const ws of clients) {
+    try {
+      ws.send("reload");
+    } catch {
+      clients.delete(ws);
+    }
+  }
+}
+function broadcastCss(css) {
+  const msg = JSON.stringify({ type: "css", css });
+  for (const ws of clients) {
+    try {
+      ws.send(msg);
+    } catch {
+      clients.delete(ws);
+    }
+  }
+}
+function liveReload(dir) {
+  const r = new Router();
+  const resolved = resolve6(dir);
+  const entryPath = join4(resolved, "page.tsx");
+  r.get("/__wfw/v/bundle", async (req, ctx) => {
+    const code = await compileVendorBundle();
+    return new Response(code, {
+      headers: { "content-type": "application/javascript; charset=utf-8" }
+    });
+  });
+  r.get("/__wfw/h/:hash", async (req, ctx) => {
+    const hash = ctx.params.hash.replace(/\.js$/i, "");
+    const code = hotBundleCache.get(hash);
+    if (!code) return new Response("", { status: 404 });
+    return new Response(code, {
+      headers: { "content-type": "application/javascript; charset=utf-8" }
+    });
+  });
+  r.ws("/__weifuwu/livereload", {
+    open(ws) {
+      clients.add(ws);
+      ws.on("close", () => clients.delete(ws));
+      ws.on("error", () => clients.delete(ws));
+    }
+  });
+  const watcher = chokidar.watch(dir, {
+    ignored: /(^|[/\\])\.|node_modules|[/\\]\.weifuwu[/\\]/,
+    ignoreInitial: true
+  });
+  watcher.on("change", async (filePath) => {
+    if (/\.tsx?$/i.test(filePath)) {
+      if (filePath.endsWith("layout.tsx")) {
+        return broadcastReload();
+      }
+      clearCompileCache();
+      markClientBundleDirty();
+      try {
+        const target = existsSync4(entryPath) ? entryPath : filePath;
+        await compileTsxDev(target);
+        const { hash, code } = await compileHotComponent(target);
+        setHot(hash, code);
+        let css;
+        const cssPath = join4(resolved, "app.css");
+        if (existsSync4(cssPath)) {
+          css = await compileTailwindCss(cssPath, resolved);
+        }
+        const entry = id(entryPath);
+        const msg = { type: "component", hash, entry };
+        if (css) msg.css = css;
+        const str = JSON.stringify(msg);
+        for (const ws of clients) {
+          try {
+            ws.send(str);
+          } catch {
+            clients.delete(ws);
+          }
+        }
+      } catch (e) {
+        console.error("live reload failed, fallback to full reload:", e);
+        broadcastReload();
+      }
+    } else if (/\.css$/i.test(filePath)) {
+      const cssPath = join4(resolved, "app.css");
+      if (existsSync4(cssPath)) {
+        const css = await compileTailwindCss(cssPath, resolved);
+        if (css) broadcastCss(css);
+      }
+    }
+  });
+  r.close = () => {
+    watcher.close();
+    clients.clear();
   };
+  return r;
+}
+
+// root-layout.ts
+function rootLayout(dir) {
+  const r = new Router();
+  const resolved = resolve7(dir);
+  const isDev2 = process.env.NODE_ENV !== "production";
+  const layoutPath = join5(resolved, "layout.tsx");
+  r.use(async (req, ctx, next) => {
+    const mod = await compile(layoutPath);
+    if (mod?.default) ctx.layoutStack = [{ path: layoutPath, component: mod.default }];
+    return next(req, ctx);
+  });
+  if (existsSync5(join5(resolved, "app.css"))) {
+    r.use(tailwind(resolved));
+  }
+  if (isDev2) {
+    const lr = liveReload(resolved);
+    r.use(lr);
+    r.close = lr.close;
+  }
+  return r;
 }
 
 // opencode/session.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { join as join4 } from "node:path";
+import { join as join6 } from "node:path";
 import { mkdir as mkdir2 } from "node:fs/promises";
 var sessions = pgTable("_opencode_sessions", {
   id: uuid("id"),
@@ -5701,7 +5727,7 @@ async function createSession(sql2, opts, cwd, mountPath) {
 }
 function computeSessionWorkspace(cwd, mountPath, sessionId) {
   const name = !mountPath || mountPath === "/" ? "default" : mountPath.replace(/^\//, "");
-  return join4(cwd, ".sessions", name, sessionId);
+  return join6(cwd, ".sessions", name, sessionId);
 }
 async function getSession(sql2, id3) {
   const { data: rows } = await sessions.readMany(sql2, { id: id3, active: true });
@@ -5898,10 +5924,10 @@ function createBashTool(ctx) {
         return { stdout: "", stderr: "Command denied: potentially dangerous command", exitCode: 1 };
       }
       const cwd = workdir ? `${ctx.workspace}/${workdir}` : ctx.workspace;
-      return new Promise((resolve14) => {
+      return new Promise((resolve15) => {
         const child = exec(command, { cwd, timeout: timeout * 1e3, maxBuffer: 1024 * 1024 }, (error, stdout, stderr) => {
           const truncated = stdout.length > 1e6 || stderr.length > 1e6;
-          resolve14({
+          resolve15({
             stdout: stdout.slice(0, 1e6),
             stderr: stderr.slice(0, 1e6),
             exitCode: error?.code ?? 0,
@@ -5918,7 +5944,7 @@ function createBashTool(ctx) {
 import { tool as tool4 } from "ai";
 import { z as z6 } from "zod";
 import { readFileSync as readFileSync4 } from "node:fs";
-import { resolve as resolve6 } from "node:path";
+import { resolve as resolve8 } from "node:path";
 function createReadTool(ctx) {
   return tool4({
     description: "Read file contents. Supports offset and limit for reading specific line ranges.",
@@ -5928,7 +5954,7 @@ function createReadTool(ctx) {
       limit: z6.number().optional().describe("Number of lines to read")
     }),
     execute: async ({ path: path2, offset, limit }) => {
-      const resolved = resolve6(ctx.workspace, path2);
+      const resolved = resolve8(ctx.workspace, path2);
       if (!isPathAllowed(resolved, ctx.workspace, ctx.permissions)) {
         return { error: "Path not allowed", content: null, totalLines: 0 };
       }
@@ -5960,7 +5986,7 @@ function createReadTool(ctx) {
 import { tool as tool5 } from "ai";
 import { z as z7 } from "zod";
 import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync3 } from "node:fs";
-import { resolve as resolve7, dirname as dirname3 } from "node:path";
+import { resolve as resolve9, dirname as dirname3 } from "node:path";
 function createWriteTool(ctx) {
   return tool5({
     description: "Create or overwrite a file. Parent directories are created automatically.",
@@ -5969,7 +5995,7 @@ function createWriteTool(ctx) {
       content: z7.string().describe("File content")
     }),
     execute: async ({ path: path2, content }) => {
-      const resolved = resolve7(ctx.workspace, path2);
+      const resolved = resolve9(ctx.workspace, path2);
       if (!isPathAllowed(resolved, ctx.workspace, ctx.permissions)) {
         return { error: "Path not allowed" };
       }
@@ -5984,7 +6010,7 @@ function createWriteTool(ctx) {
 import { tool as tool6 } from "ai";
 import { z as z8 } from "zod";
 import { readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
-import { resolve as resolve8 } from "node:path";
+import { resolve as resolve10 } from "node:path";
 function createEditTool(ctx) {
   return tool6({
     description: "Perform exact string replacements in a file. If oldString appears multiple times, provide more surrounding context.",
@@ -5995,7 +6021,7 @@ function createEditTool(ctx) {
       replaceAll: z8.boolean().default(false).describe("Replace all occurrences")
     }),
     execute: async ({ path: path2, oldString, newString, replaceAll }) => {
-      const resolved = resolve8(ctx.workspace, path2);
+      const resolved = resolve10(ctx.workspace, path2);
       if (!isPathAllowed(resolved, ctx.workspace, ctx.permissions)) {
         return { error: "Path not allowed" };
       }
@@ -6028,8 +6054,8 @@ function createEditTool(ctx) {
 import { tool as tool7 } from "ai";
 import { z as z9 } from "zod";
 import { execFileSync } from "node:child_process";
-import { resolve as resolve9 } from "node:path";
-import { existsSync as existsSync4 } from "node:fs";
+import { resolve as resolve11 } from "node:path";
+import { existsSync as existsSync6 } from "node:fs";
 function createGrepTool(ctx) {
   return tool7({
     description: "Search file contents using regex. Supports file type filtering and context lines.",
@@ -6040,10 +6066,10 @@ function createGrepTool(ctx) {
       context: z9.number().default(0).describe("Number of context lines before and after each match")
     }),
     execute: async ({ pattern, include, path: path2, context }) => {
-      const searchDir = path2 ? resolve9(ctx.workspace, path2) : ctx.workspace;
+      const searchDir = path2 ? resolve11(ctx.workspace, path2) : ctx.workspace;
       try {
         let stdout;
-        if (existsSync4("/usr/bin/rg") || existsSync4("/usr/local/bin/rg")) {
+        if (existsSync6("/usr/bin/rg") || existsSync6("/usr/local/bin/rg")) {
           const args = ["-n"];
           if (context > 0) args.push("-C", String(context));
           if (include) args.push("-g", include);
@@ -6072,7 +6098,7 @@ function createGrepTool(ctx) {
 import { tool as tool8 } from "ai";
 import { z as z10 } from "zod";
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { resolve as resolve10 } from "node:path";
+import { resolve as resolve12 } from "node:path";
 function createGlobTool(ctx) {
   return tool8({
     description: "Find files matching a glob pattern.",
@@ -6081,7 +6107,7 @@ function createGlobTool(ctx) {
       path: z10.string().optional().describe("Subdirectory relative to workspace")
     }),
     execute: async ({ pattern, path: path2 }) => {
-      const searchDir = path2 ? resolve10(ctx.workspace, path2) : ctx.workspace;
+      const searchDir = path2 ? resolve12(ctx.workspace, path2) : ctx.workspace;
       try {
         const stdout = execFileSync2("find", [
           searchDir,
@@ -6142,7 +6168,7 @@ function createQuestionTool(ctx) {
       options: z12.array(z12.string()).optional().describe("Optional multiple choice options")
     }),
     execute: async ({ question, options }, { toolCallId }) => {
-      return new Promise((resolve14, reject) => {
+      return new Promise((resolve15, reject) => {
         const timeout = setTimeout(() => {
           ctx.pendingQuestions.delete(toolCallId);
           reject(new Error("Question timed out"));
@@ -6150,7 +6176,7 @@ function createQuestionTool(ctx) {
         ctx.pendingQuestions.set(toolCallId, {
           resolve: (answer) => {
             clearTimeout(timeout);
-            resolve14(answer);
+            resolve15(answer);
           },
           reject: (err) => {
             clearTimeout(timeout);
@@ -6297,9 +6323,8 @@ async function buildRouter4(deps) {
   });
   try {
     const uiDir = new URL("../opencode/ui/", import.meta.url).pathname;
-    router.use(tailwind(uiDir));
-    router.use(layout(join5(uiDir, "layout.tsx")));
-    router.get("/", ssr(join5(uiDir, "page.tsx")));
+    router.use(rootLayout(uiDir));
+    router.get("/", ssr(join7(uiDir, "page.tsx")));
   } catch (e) {
     console.warn("[opencode] UI not available:", e);
   }
@@ -6307,17 +6332,17 @@ async function buildRouter4(deps) {
 }
 
 // opencode/ws.ts
-var clients = /* @__PURE__ */ new WeakMap();
+var clients2 = /* @__PURE__ */ new WeakMap();
 function createWSHandler2(deps) {
   const { sql: sql2, model, workspace, systemPrompt, skills, skillsRegistry, permissions, pendingQuestions } = deps;
   return {
     open(ws, ctx) {
       const userId = ctx.user?.id ?? 0;
       const mountPath = ctx.mountPath ?? "";
-      clients.set(ws, { userId, mountPath });
+      clients2.set(ws, { userId, mountPath });
     },
     async message(ws, ctx, data) {
-      const client = clients.get(ws);
+      const client = clients2.get(ws);
       if (!client) return;
       let msg;
       try {
@@ -6414,17 +6439,17 @@ function createWSHandler2(deps) {
       }
     },
     close(ws) {
-      const client = clients.get(ws);
+      const client = clients2.get(ws);
       if (client) {
         client.abortController?.abort();
-        clients.delete(ws);
+        clients2.delete(ws);
       }
     },
     error(ws, _ctx, _err) {
-      const client = clients.get(ws);
+      const client = clients2.get(ws);
       if (client) {
         client.abortController?.abort();
-        clients.delete(ws);
+        clients2.delete(ws);
       }
     }
   };
@@ -6434,7 +6459,7 @@ function createWSHandler2(deps) {
 import { readFile } from "node:fs/promises";
 import { glob } from "node:fs/promises";
 import { homedir } from "node:os";
-import { resolve as resolve11 } from "node:path";
+import { resolve as resolve13 } from "node:path";
 import { parse as parseYaml } from "yaml";
 var SEARCH_DIRS = [
   (ws) => `${ws}/.opencode/skills`,
@@ -6472,7 +6497,7 @@ async function scanDir(dir) {
   try {
     const files = [];
     for await (const entry of glob("*/SKILL.md", { cwd: dir })) {
-      const skill = await parseSkillFile(resolve11(dir, entry));
+      const skill = await parseSkillFile(resolve13(dir, entry));
       if (skill) files.push(skill);
     }
     return files;
@@ -6807,8 +6832,8 @@ function analytics(options) {
 
 // preferences.ts
 import { readFile as readFile2 } from "node:fs/promises";
-import { existsSync as existsSync5 } from "node:fs";
-import { join as join6, resolve as resolve12 } from "node:path";
+import { existsSync as existsSync7 } from "node:fs";
+import { join as join8, resolve as resolve14 } from "node:path";
 var defaults = {
   locale: { default: "en", cookie: "locale", fromAcceptLanguage: true },
   theme: { default: "system", cookie: "theme" }
@@ -6857,7 +6882,7 @@ async function handlePrefSwitch(req, value, cookieName, load) {
   });
 }
 function preferences(options) {
-  const dir = options.dir ? resolve12(options.dir) : void 0;
+  const dir = options.dir ? resolve14(options.dir) : void 0;
   const localeOpts = { ...defaults.locale, ...options.locale };
   const themeOpts = { ...defaults.theme, ...options.theme };
   const cache2 = /* @__PURE__ */ new Map();
@@ -6869,8 +6894,8 @@ function preferences(options) {
     if (!validLocale(locale)) return {};
     const cached = cache2.get(locale);
     if (cached) return cached;
-    const filePath = join6(dir, `${locale}.json`);
-    if (existsSync5(filePath)) {
+    const filePath = join8(dir, `${locale}.json`);
+    if (existsSync7(filePath)) {
       try {
         const content = await readFile2(filePath, "utf-8");
         const data = JSON.parse(content);
@@ -7906,12 +7931,12 @@ function iii(opts = {}) {
     const handler = async (payload) => {
       if (!worker.ws) throw new Error(`Worker "${worker.name}" disconnected`);
       const invocationId = crypto6.randomUUID();
-      return new Promise((resolve14, reject) => {
+      return new Promise((resolve15, reject) => {
         const timer = setTimeout(() => {
           pending.delete(invocationId);
           reject(new Error(`Invocation timed out for "${id3}"`));
         }, 3e4);
-        pending.set(invocationId, { resolve: resolve14, reject, timer });
+        pending.set(invocationId, { resolve: resolve15, reject, timer });
         worker.ws.send(JSON.stringify({
           type: "invoke",
           invocation_id: invocationId,
@@ -8152,8 +8177,8 @@ function registerWorker(url) {
   function connect() {
     if (intentionalClose) return;
     ws = new WebSocket(url);
-    ready = new Promise((resolve14) => {
-      resolveReady = resolve14;
+    ready = new Promise((resolve15) => {
+      resolveReady = resolve15;
     });
     ws.onopen = () => {
       reconnectAttempt = 0;
@@ -8273,13 +8298,13 @@ function registerWorker(url) {
         }
         return Promise.resolve(fn(request.payload, ctx));
       }
-      return new Promise((resolve14, reject) => {
+      return new Promise((resolve15, reject) => {
         const invocationId = genId();
         const timer = setTimeout(() => {
           pendingInvocations.delete(invocationId);
           reject(new Error(`Invocation timed out for "${request.function_id}"`));
         }, request.timeout_ms || 3e4);
-        pendingInvocations.set(invocationId, { resolve: resolve14, reject, timer });
+        pendingInvocations.set(invocationId, { resolve: resolve15, reject, timer });
         send({
           type: "invoke",
           invocation_id: invocationId,
@@ -8300,142 +8325,70 @@ function registerWorker(url) {
   };
 }
 
-// live.ts
-import chokidar from "chokidar";
-import { existsSync as existsSync6 } from "node:fs";
-import { join as join7, resolve as resolve13 } from "node:path";
-var clients2 = /* @__PURE__ */ new Set();
-var hotBundleCache = /* @__PURE__ */ new Map();
-var hotKeys = [];
-var MAX_HOT = 10;
-function setHot(hash, code) {
-  if (!hotBundleCache.has(hash)) {
-    hotKeys.push(hash);
-    if (hotKeys.length > MAX_HOT) {
-      const old = hotKeys.shift();
-      hotBundleCache.delete(old);
-    }
-  }
-  hotBundleCache.set(hash, code);
-}
-function broadcastReload() {
-  for (const ws of clients2) {
-    try {
-      ws.send("reload");
-    } catch {
-      clients2.delete(ws);
-    }
-  }
-}
-function broadcastCss(css) {
-  const msg = JSON.stringify({ type: "css", css });
-  for (const ws of clients2) {
-    try {
-      ws.send(msg);
-    } catch {
-      clients2.delete(ws);
-    }
-  }
-}
-function liveReload(opts) {
-  const r = new Router();
-  const entryPath = (() => {
-    for (const dir of opts.dirs) {
-      const p = join7(resolve13(dir), "page.tsx");
-      if (existsSync6(p)) return p;
-    }
-    return "";
-  })();
-  r.get("/__wfw/v/bundle", async (req, ctx) => {
-    const code = await compileVendorBundle();
-    return new Response(code, {
-      headers: { "content-type": "application/javascript; charset=utf-8" }
-    });
-  });
-  r.get("/__wfw/h/:hash", async (req, ctx) => {
-    const hash = ctx.params.hash.replace(/\.js$/i, "");
-    const code = hotBundleCache.get(hash);
-    if (!code) return new Response("", { status: 404 });
-    return new Response(code, {
-      headers: { "content-type": "application/javascript; charset=utf-8" }
-    });
-  });
-  r.ws("/__weifuwu/livereload", {
-    open(ws) {
-      clients2.add(ws);
-      ws.on("close", () => clients2.delete(ws));
-      ws.on("error", () => clients2.delete(ws));
-    }
-  });
-  const watcher = chokidar.watch(opts.dirs, {
-    ignored: /(^|[/\\])\.|node_modules|[/\\]\.weifuwu[/\\]/,
-    ignoreInitial: true
-  });
-  watcher.on("change", async (filePath) => {
-    if (/\.tsx?$/i.test(filePath)) {
-      clearCompileCache();
-      markClientBundleDirty();
-      try {
-        const target = entryPath || filePath;
-        await compileTsxDev(target);
-        const { hash, code } = await compileHotComponent(target);
-        setHot(hash, code);
-        let css;
-        for (const dir of opts.dirs) {
-          const cssPath = join7(resolve13(dir), "app.css");
-          if (existsSync6(cssPath)) {
-            css = await compileTailwindCss(cssPath, resolve13(dir));
-          }
-        }
-        const entry = entryPath ? id(entryPath) : "";
-        const msg = { type: "component", hash, entry };
-        if (css) msg.css = css;
-        const str = JSON.stringify(msg);
-        for (const ws of clients2) {
-          try {
-            ws.send(str);
-          } catch {
-            clients2.delete(ws);
-          }
-        }
-      } catch (e) {
-        console.error("live reload failed, fallback to full reload:", e);
-        broadcastReload();
-      }
-    } else if (/\.css$/i.test(filePath)) {
-      for (const dir of opts.dirs) {
-        const cssPath = join7(resolve13(dir), "app.css");
-        if (existsSync6(cssPath)) {
-          const css = await compileTailwindCss(cssPath, resolve13(dir));
-          if (css) broadcastCss(css);
-        }
-      }
-    }
-  });
-  r.close = () => {
-    watcher.close();
-    clients2.clear();
+// layout.ts
+function layout(path2) {
+  return async (req, ctx, next) => {
+    const mod = await compile(path2);
+    const Component = mod.default;
+    if (!Component) throw new Error(`Layout ${path2} has no default export`);
+    ctx.layoutStack = [...ctx.layoutStack || [], { path: path2, component: Component }];
+    return next(req, ctx);
   };
-  return r;
 }
 
 // not-found.ts
+import { createElement as createElement2 } from "react";
 function notFound(path2) {
   return async (req, ctx) => {
     if (!path2) return new Response("Not Found", { status: 404 });
-    const mod = await compile(path2);
-    const Component = mod?.default;
-    const body = Component ? "404 - Not Found" : "404 - Not Found";
-    return new Response(body, {
-      status: 404,
-      headers: { "content-type": "text/html; charset=utf-8" }
+    let Component;
+    try {
+      const mod = await compile(path2);
+      Component = mod?.default;
+    } catch {
+      return new Response("Not Found", { status: 404 });
+    }
+    if (!Component) return new Response("Not Found", { status: 404 });
+    const layouts = ctx.layoutStack || [];
+    const layoutComponents = layouts.map((l) => l.component);
+    const base = (ctx.mountPath || "").replace(/\/$/, "");
+    let element = createElement2(
+      "div",
+      { id: "__weifuwu_root" },
+      createElement2(Component, null)
+    );
+    if (layoutComponents.length === 0) {
+      element = createElement2(
+        "html",
+        { lang: "en" },
+        createElement2(
+          "head",
+          null,
+          createElement2("meta", { charSet: "utf-8" }),
+          createElement2("meta", { name: "viewport", content: "width=device-width, initial-scale=1" }),
+          createElement2("title", null, "404")
+        ),
+        createElement2("body", null, element)
+      );
+    } else {
+      for (const L of layoutComponents.toReversed()) {
+        element = createElement2(L, { children: element });
+      }
+    }
+    const { renderToReadableStream } = await import("react-dom/server");
+    const stream = await renderToReadableStream(element);
+    return streamResponse(stream, {
+      ctx,
+      base,
+      isDev: process.env.NODE_ENV !== "production",
+      compiledTailwindCss: ctx.compiledTailwindCss,
+      status: 404
     });
   };
 }
 
 // error-boundary.ts
-import { createElement as createElement2 } from "react";
-import { TextEncoder as TextEncoder3 } from "node:util";
+import { createElement as createElement3 } from "react";
 function errorBoundary(errorPath) {
   return async (req, ctx, next) => {
     try {
@@ -8445,30 +8398,38 @@ function errorBoundary(errorPath) {
       const ErrorComponent = mod.default;
       if (!ErrorComponent) throw err;
       const layouts = (ctx.layoutStack || []).map((l) => l.component);
-      const stream = await import("react-dom/server").then((m) => m.renderToReadableStream(
-        createElement2(ErrorComponent, {
-          error: err instanceof Error ? err : new Error(String(err)),
-          reset: () => {
-          }
-        })
-      ));
-      const reader = stream.getReader();
-      const chunks = [];
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        chunks.push(value);
-      }
-      const encoder2 = new TextEncoder3();
-      const body = chunks.reduce((acc, c) => {
-        const merged = new Uint8Array(acc.length + c.length);
-        merged.set(acc);
-        merged.set(c, acc.length);
-        return merged;
-      }, new Uint8Array(0));
-      return new Response(body, {
-        status: 500,
-        headers: { "content-type": "text/html; charset=utf-8" }
+      const base = (ctx.mountPath || "").replace(/\/$/, "");
+      let element = createElement3(ErrorComponent, {
+        error: err instanceof Error ? err : new Error(String(err)),
+        reset: () => {
+        }
+      });
+      if (layouts.length === 0) {
+        element = createElement3(
+          "html",
+          { lang: "en" },
+          createElement3(
+            "head",
+            null,
+            createElement3("meta", { charSet: "utf-8" }),
+            createElement3("meta", { name: "viewport", content: "width=device-width, initial-scale=1" }),
+            createElement3("title", null, "500")
+          ),
+          createElement3("body", null, element)
+        );
+      } else {
+        for (const L of layouts.toReversed()) {
+          element = createElement3(L, { children: element });
+        }
+      }
+      const { renderToReadableStream } = await import("react-dom/server");
+      const stream = await renderToReadableStream(element);
+      return streamResponse(stream, {
+        ctx,
+        base,
+        isDev: process.env.NODE_ENV !== "production",
+        compiledTailwindCss: ctx.compiledTailwindCss,
+        status: 500
       });
     }
   };
@@ -8505,7 +8466,6 @@ export {
   helmet,
   iii,
   layout,
-  liveReload,
   loadEnv,
   logdb,
   logger,
@@ -8521,6 +8481,7 @@ export {
   redis,
   registerWorker,
   requestId,
+  rootLayout,
   runWorkflow,
   seo,
   seoMiddleware,
@@ -8532,7 +8493,6 @@ export {
   ssr,
   streamObject,
   streamText,
-  tailwind,
   tenant,
   tool2 as tool,
   upload,