weifuwu 0.7.0 → 0.8.1

package/README.md

@@ -28,6 +28,7 @@ Everything follows the same `(req, ctx) => Response` contract. The Router handle
 - **Static files** — `serveStatic()` with ETag, 304, MIME, directory index
 - **Cookie** — `getCookies()`, `setCookie()`, `deleteCookie()` — immutable
 - **Error handling** — global `onError()`
+- **Deploy** — `deploy()` — self-hosted PaaS: multi-app reverse proxy, subdomain routing, zero-downtime updates, auto SSL, Git-based deployment
 - **Zero build** — native TypeScript in Node.js v24+
 - **Zero deps** (core) — only `node:http` and `node:stream`
 
@@ -998,6 +999,42 @@ const app = new Router()
   .get('/crash', () => { throw new Error('boom') })
 ```
 
+## Deploy
+
+See [deploy.md](./deploy.md) for complete documentation — VPS setup, subdomain routing, blue-green zero-downtime, WebSocket bridge, Git webhook, auto SSL, and management API.
+
+Quick start on a fresh VPS:
+
+```bash
+# 1. Install Node.js
+curl -fsSL https://deb.nodesource.com/setup_24.x | bash -
+apt-get install -y nodejs git
+
+# 2. Create deploy project
+mkdir -p /opt/deploy && cd /opt/deploy
+npm init -y && npm install weifuwu
+
+# 3. Write deploy.ts
+cat > deploy.ts << 'EOF'
+import { deploy, defineConfig } from 'weifuwu'
+await deploy(defineConfig({
+  domain: 'example.com',
+  deployToken: process.env.DEPLOY_TOKEN,
+  apps: {
+    blog: {
+      repo: 'https://github.com/me/my-blog.git',
+      subdomain: 'blog',
+      entry: 'app.ts',
+      port: 3001,
+    },
+  },
+}))
+EOF
+
+# 4. Run
+DEPLOY_TOKEN='my-secret' node deploy.ts
+```
+
 ## API
 
 ### `serve(handler, options?)`
@@ -1099,6 +1136,13 @@ Returns `Promise<Router>`.
 | `ai(handler)` | AI streaming endpoint (POST) |
 | `workflow(handler)` | Workflow engine (POST + SSE) |
 
+### Deploy
+
+| Import | Description |
+|--------|-------------|
+| `deploy(config)` | Start the deployment platform — see [deploy.md](./deploy.md) |
+| `defineConfig(config)` | Type-safe config helper with validation — see [deploy.md](./deploy.md) |
+
 ### Utilities
 
 | Function | Description |

package/dist/deploy/config.d.ts

@@ -0,0 +1,2 @@
+import type { DeployConfig } from './types.ts';
+export declare function defineConfig(config: DeployConfig): DeployConfig;

package/dist/deploy/gateway.d.ts

@@ -0,0 +1,2 @@
+import type { DeployConfig, GatewayResult } from './types.ts';
+export declare function createGateway(config: DeployConfig, getPort: (name: string) => number | undefined): GatewayResult;

package/dist/deploy/index.d.ts

@@ -0,0 +1,4 @@
+import type { DeployConfig, DeployServer } from './types.ts';
+export { defineConfig } from './config.ts';
+export type { DeployConfig, AppConfig, DeployServer, AppStatus, GatewayResult } from './types.ts';
+export declare function deploy(config: DeployConfig): Promise<DeployServer>;

package/dist/deploy/manager.d.ts

@@ -0,0 +1,16 @@
+import { Router } from '../router.ts';
+import type { DeployConfig, AppStatus } from './types.ts';
+export interface AppRuntime {
+    config: import('./types.ts').AppConfig;
+    status: AppStatus;
+    logs: string[];
+    process: import('node:child_process').ChildProcess | null;
+    currentPort: number;
+    startedAt: number | null;
+    restartCount: number;
+    restartTimer: ReturnType<typeof setTimeout> | undefined;
+}
+export declare function createManager(config: DeployConfig, apps: Map<string, AppRuntime>, manager: {
+    deployApp(name: string): Promise<void>;
+    reloadConfig(): Promise<void>;
+}): Router;

package/dist/deploy/process.d.ts

@@ -0,0 +1,14 @@
+import { type ChildProcess } from 'node:child_process';
+export interface ManagedProcess {
+    child: ChildProcess;
+    port: number;
+}
+export declare function forkApp(opts: {
+    cwd: string;
+    entry: string;
+    port: number;
+    env?: Record<string, string>;
+    onLog?: (line: string) => void;
+}): ManagedProcess;
+export declare function stopProcess(mp: ManagedProcess, timeout?: number): Promise<void>;
+export declare function healthCheck(port: number, path?: string): Promise<boolean>;

package/dist/deploy/types.d.ts

@@ -0,0 +1,62 @@
+import type { IncomingMessage } from 'node:http';
+import type { Duplex } from 'node:stream';
+import type { Handler } from '../types.ts';
+export interface DeployConfig {
+    domain: string;
+    port?: number;
+    ssl?: {
+        email: string;
+        staging?: boolean;
+    };
+    deployToken?: string;
+    webhookSecret?: string;
+    appsDir?: string;
+    defaultApp?: string;
+    apps: Record<string, AppConfig>;
+}
+export interface AppConfig {
+    repo: string;
+    branch?: string;
+    subdomain?: string;
+    path?: string;
+    port: number;
+    ports?: [number, number];
+    entry: string;
+    env?: Record<string, string>;
+    healthEndpoint?: string;
+    buildCommand?: string;
+}
+export interface AppStatus {
+    name: string;
+    status: 'starting' | 'running' | 'stopped' | 'error';
+    port: number;
+    subdomain?: string;
+    path?: string;
+    pid?: number;
+    uptime?: number;
+    error?: string;
+}
+export interface DeployServer {
+    stop(): Promise<void>;
+    ready: Promise<void>;
+    url: string;
+    apps: {
+        list(): AppStatus[];
+        status(name: string): AppStatus | undefined;
+        deploy(name: string): Promise<void>;
+        restart(name: string): Promise<void>;
+        stop(name: string): Promise<void>;
+        start(name: string): Promise<void>;
+    };
+}
+export interface GatewayResult {
+    handler: Handler;
+    wsHandler: (req: IncomingMessage, socket: Duplex, head: Buffer) => void;
+}
+declare module '../types.ts' {
+    interface Context {
+        deploy?: {
+            appName?: string;
+        };
+    }
+}

package/dist/index.d.ts

@@ -39,3 +39,5 @@ export { agent } from './agent/index.ts';
 export type { AgentOptions, AgentModule, AgentConfig, RunParams, RunResult, KnowledgeDoc } from './agent/types.ts';
 export { messager } from './messager/index.ts';
 export type { MessagerOptions, MessagerModule, Channel, ChannelMember, Message } from './messager/types.ts';
+export { deploy, defineConfig } from './deploy/index.ts';
+export type { DeployConfig, AppConfig, DeployServer, AppStatus } from './deploy/types.ts';

package/dist/index.js

@@ -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");
     }
@@ -10918,38 +10938,38 @@ var Router = class _Router {
     }
     return this;
   }
-  get(path, ...args) {
-    return this.route("GET", path, ...args);
+  get(path2, ...args) {
+    return this.route("GET", path2, ...args);
   }
-  post(path, ...args) {
-    return this.route("POST", path, ...args);
+  post(path2, ...args) {
+    return this.route("POST", path2, ...args);
   }
-  put(path, ...args) {
-    return this.route("PUT", path, ...args);
+  put(path2, ...args) {
+    return this.route("PUT", path2, ...args);
   }
-  delete(path, ...args) {
-    return this.route("DELETE", path, ...args);
+  delete(path2, ...args) {
+    return this.route("DELETE", path2, ...args);
   }
-  patch(path, ...args) {
-    return this.route("PATCH", path, ...args);
+  patch(path2, ...args) {
+    return this.route("PATCH", path2, ...args);
   }
-  head(path, ...args) {
-    return this.route("HEAD", path, ...args);
+  head(path2, ...args) {
+    return this.route("HEAD", path2, ...args);
   }
-  options(path, ...args) {
-    return this.route("OPTIONS", path, ...args);
+  options(path2, ...args) {
+    return this.route("OPTIONS", path2, ...args);
   }
-  all(path, ...args) {
-    return this.route("*", path, ...args);
+  all(path2, ...args) {
+    return this.route("*", path2, ...args);
   }
   onError(handler) {
     this.errorHandler = handler;
     return this;
   }
-  route(method, path, ...args) {
+  route(method, path2, ...args) {
     const handler = args.pop();
     const middlewares = args;
-    const segments = this.splitPath(path);
+    const segments = this.splitPath(path2);
     let node = this.root;
     for (const segment of segments) {
       if (segment === "*") {
@@ -10964,10 +10984,10 @@ var Router = class _Router {
     if (middlewares.length > 0) node.middlewares.set(method, middlewares);
     return this;
   }
-  ws(path, ...args) {
+  ws(path2, ...args) {
     const handler = args.pop();
     const middlewares = args;
-    const segments = this.splitPath(path);
+    const segments = this.splitPath(path2);
     let node = this.wsRoot;
     for (const segment of segments) {
       node = getWsNode(node, segment);
@@ -11013,8 +11033,13 @@ var Router = class _Router {
           return mw(innerReq, ctx2, dispatch);
         }
         return await new Promise((resolve3) => {
-          upgradeSocket(wss, req, socket, head, match.handler, ctx2);
-          resolve3(new Response(null, { status: 101 }));
+          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) => {
@@ -11026,8 +11051,8 @@ var Router = class _Router {
       });
     };
   }
-  splitPath(path) {
-    return path.split("/").filter(Boolean);
+  splitPath(path2) {
+    return path2.split("/").filter(Boolean);
   }
   matchTrie(method, segments) {
     let node = this.root;
@@ -11815,7 +11840,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 +11856,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 +11903,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 };
@@ -12192,9 +12199,9 @@ function tool(def) {
 }
 
 // workflow/reference.ts
-function getByPath(obj, path) {
+function getByPath(obj, path2) {
   let current = obj;
-  for (const key of path) {
+  for (const key of path2) {
     if (current === null || current === void 0) return void 0;
     if (typeof current === "object" && key in current) {
       current = current[key];
@@ -12204,9 +12211,9 @@ function getByPath(obj, path) {
   }
   return current;
 }
-function resolveRef(path, ctx) {
-  if (path.startsWith("$nodes.")) {
-    const afterNodes = path.slice(7);
+function resolveRef(path2, ctx) {
+  if (path2.startsWith("$nodes.")) {
+    const afterNodes = path2.slice(7);
     const dotIdx = afterNodes.indexOf(".");
     if (dotIdx === -1) {
       return ctx.nodeOutputs.get(afterNodes);
@@ -12222,23 +12229,23 @@ function resolveRef(path, ctx) {
     }
     return getByPath(output, propPath.split("."));
   }
-  if (path.startsWith("$var.")) {
-    const name15 = path.slice(5);
+  if (path2.startsWith("$var.")) {
+    const name15 = path2.slice(5);
     if (!ctx.variables.has(name15)) {
       throw new Error(`Variable "${name15}" is not defined`);
     }
     return ctx.variables.get(name15);
   }
-  if (path.startsWith("$input.")) {
-    const key = path.slice(7);
+  if (path2.startsWith("$input.")) {
+    const key = path2.slice(7);
     return ctx.input[key];
   }
-  if (path === "true") return true;
-  if (path === "false") return false;
-  if (path === "null") return null;
-  const num = Number(path);
-  if (!isNaN(num) && path.trim() !== "") return num;
-  return path;
+  if (path2 === "true") return true;
+  if (path2 === "false") return false;
+  if (path2 === "null") return null;
+  const num = Number(path2);
+  if (!isNaN(num) && path2.trim() !== "") return num;
+  return path2;
 }
 function resolveValue(v, ctx) {
   if (typeof v === "string" && v.startsWith("$")) {
@@ -13542,12 +13549,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 +13571,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 +13862,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 +13891,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 +13910,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 +13920,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 +13960,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 +13982,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"
@@ -23884,37 +23916,37 @@ function createOpenAI(options = {}) {
   );
   const createChatModel = (modelId) => new OpenAIChatLanguageModel(modelId, {
     provider: `${providerName}.chat`,
-    url: ({ path }) => `${baseURL}${path}`,
+    url: ({ path: path2 }) => `${baseURL}${path2}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createCompletionModel = (modelId) => new OpenAICompletionLanguageModel(modelId, {
     provider: `${providerName}.completion`,
-    url: ({ path }) => `${baseURL}${path}`,
+    url: ({ path: path2 }) => `${baseURL}${path2}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createEmbeddingModel = (modelId) => new OpenAIEmbeddingModel(modelId, {
     provider: `${providerName}.embedding`,
-    url: ({ path }) => `${baseURL}${path}`,
+    url: ({ path: path2 }) => `${baseURL}${path2}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createImageModel = (modelId) => new OpenAIImageModel(modelId, {
     provider: `${providerName}.image`,
-    url: ({ path }) => `${baseURL}${path}`,
+    url: ({ path: path2 }) => `${baseURL}${path2}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createTranscriptionModel = (modelId) => new OpenAITranscriptionModel(modelId, {
     provider: `${providerName}.transcription`,
-    url: ({ path }) => `${baseURL}${path}`,
+    url: ({ path: path2 }) => `${baseURL}${path2}`,
     headers: getHeaders,
     fetch: options.fetch
   });
   const createSpeechModel = (modelId) => new OpenAISpeechModel(modelId, {
     provider: `${providerName}.speech`,
-    url: ({ path }) => `${baseURL}${path}`,
+    url: ({ path: path2 }) => `${baseURL}${path2}`,
     headers: getHeaders,
     fetch: options.fetch
   });
@@ -23929,7 +23961,7 @@ function createOpenAI(options = {}) {
   const createResponsesModel = (modelId) => {
     return new OpenAIResponsesLanguageModel(modelId, {
       provider: `${providerName}.responses`,
-      url: ({ path }) => `${baseURL}${path}`,
+      url: ({ path: path2 }) => `${baseURL}${path2}`,
       headers: getHeaders,
       fetch: options.fetch,
       fileIdPrefixes: ["file-"]
@@ -24407,15 +24439,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 +24462,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 +24607,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);
         });
       }
     }
@@ -24628,6 +24668,540 @@ function messager(options) {
     }
   };
 }
+
+// deploy/index.ts
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+
+// deploy/gateway.ts
+import WebSocket, { WebSocketServer as WebSocketServer2 } from "ws";
+function isBareDomain(host, domain) {
+  return host === domain || host === `www.${domain}`;
+}
+function matchApp(config, getPort, host, pathname) {
+  for (const [name15, ac] of Object.entries(config.apps)) {
+    if (ac.subdomain && host === `${ac.subdomain}.${config.domain}`) {
+      const port = getPort(name15);
+      if (port) return { name: name15, port };
+    }
+  }
+  const pathApps = Object.entries(config.apps).filter(([, ac]) => ac.path).sort(([, a], [, b]) => (b.path?.length ?? 0) - (a.path?.length ?? 0));
+  for (const [name15, ac] of pathApps) {
+    if (ac.path && pathname.startsWith(ac.path)) {
+      const port = getPort(name15);
+      if (port) return { name: name15, port, stripPath: ac.path };
+    }
+  }
+  if (config.defaultApp && isBareDomain(host, config.domain)) {
+    const port = getPort(config.defaultApp);
+    if (port) return { name: config.defaultApp, port };
+  }
+  return void 0;
+}
+function createGateway(config, getPort) {
+  const handler = async (req) => {
+    const url = new URL(req.url);
+    const match = matchApp(config, getPort, url.hostname, url.pathname);
+    if (!match) return new Response("Not Found", { status: 404 });
+    let targetPath = url.pathname;
+    if (match.stripPath && targetPath.startsWith(match.stripPath)) {
+      targetPath = targetPath.slice(match.stripPath.length) || "/";
+    }
+    const target = `http://127.0.0.1:${match.port}${targetPath}${url.search}`;
+    try {
+      const proxyReq = new Request(target, {
+        method: req.method,
+        headers: req.headers,
+        body: req.method !== "GET" && req.method !== "HEAD" ? req.body : null
+      });
+      return await fetch(proxyReq);
+    } catch {
+      return new Response("Bad Gateway", { status: 502 });
+    }
+  };
+  const wss = new WebSocketServer2({ noServer: true });
+  const wsHandler = (req, socket, head) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const host = req.headers.host?.split(":")[0] ?? "";
+    const match = matchApp(config, getPort, host, url.pathname);
+    if (!match) {
+      socket.write("HTTP/1.1 404 Not Found\r\n\r\n");
+      socket.destroy();
+      return;
+    }
+    let targetPath = url.pathname;
+    if (match.stripPath && targetPath.startsWith(match.stripPath)) {
+      targetPath = targetPath.slice(match.stripPath.length) || "/";
+    }
+    const wsUrl = `ws://127.0.0.1:${match.port}${targetPath}${url.search}`;
+    const backendWS = new WebSocket(wsUrl);
+    backendWS.on("open", () => {
+      wss.handleUpgrade(req, socket, head, (clientWS) => {
+        const clientSend = (data) => {
+          clientWS.send(data);
+        };
+        const backendSend = (data) => {
+          backendWS.send(data);
+        };
+        clientWS.on("message", backendSend);
+        backendWS.on("message", clientSend);
+        clientWS.on("close", () => backendWS.close());
+        backendWS.on("close", () => clientWS.close());
+        clientWS.on("error", () => backendWS.close());
+        backendWS.on("error", () => clientWS.close());
+      });
+    });
+    backendWS.on("error", () => {
+      socket.write("HTTP/1.1 502 Bad Gateway\r\n\r\n");
+      socket.destroy();
+    });
+  };
+  return { handler, wsHandler };
+}
+
+// deploy/manager.ts
+import crypto4 from "node:crypto";
+function createManager(config, apps, manager) {
+  const router = new Router();
+  const auth2 = (req, ctx, next) => {
+    if (!config.deployToken) return next(req, ctx);
+    const header = req.headers.get("authorization") ?? "";
+    const token = header.replace("Bearer ", "");
+    if (token !== config.deployToken) {
+      return Response.json({ error: "Unauthorized" }, { status: 401 });
+    }
+    return next(req, ctx);
+  };
+  router.get("/apps", auth2, () => {
+    const list = Array.from(apps.values()).map((a) => a.status);
+    return Response.json(list);
+  });
+  router.get("/apps/:name", auth2, (req, ctx) => {
+    const app = apps.get(ctx.params.name);
+    if (!app) return new Response("Not Found", { status: 404 });
+    return Response.json(app.status);
+  });
+  router.post("/apps/:name/deploy", auth2, async (req, ctx) => {
+    const app = apps.get(ctx.params.name);
+    if (!app) return new Response("Not Found", { status: 404 });
+    try {
+      await manager.deployApp(ctx.params.name);
+      return Response.json({ success: true });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return Response.json({ error: msg }, { status: 500 });
+    }
+  });
+  router.post("/apps/:name/restart", auth2, async (req, ctx) => {
+    const app = apps.get(ctx.params.name);
+    if (!app) return new Response("Not Found", { status: 404 });
+    try {
+      await manager.deployApp(ctx.params.name);
+      return Response.json({ success: true });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return Response.json({ error: msg }, { status: 500 });
+    }
+  });
+  router.post("/apps/:name/stop", auth2, async (req, ctx) => {
+    const app = apps.get(ctx.params.name);
+    if (!app) return new Response("Not Found", { status: 404 });
+    if (app.process) {
+      app.process.kill("SIGTERM");
+      app.process = null;
+    }
+    app.status = { ...app.status, status: "stopped", pid: void 0 };
+    return Response.json({ success: true });
+  });
+  router.post("/apps/:name/start", auth2, async (req, ctx) => {
+    const app = apps.get(ctx.params.name);
+    if (!app) return new Response("Not Found", { status: 404 });
+    try {
+      await manager.deployApp(ctx.params.name);
+      return Response.json({ success: true });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return Response.json({ error: msg }, { status: 500 });
+    }
+  });
+  router.get("/apps/:name/logs", auth2, (req, ctx) => {
+    const app = apps.get(ctx.params.name);
+    if (!app) return new Response("Not Found", { status: 404 });
+    let index = app.logs.length;
+    let interval;
+    const stream = new ReadableStream({
+      start(controller) {
+        for (const line of app.logs) {
+          controller.enqueue(`data: ${JSON.stringify({ line })}
+
+`);
+        }
+        interval = setInterval(() => {
+          while (index < app.logs.length) {
+            controller.enqueue(`data: ${JSON.stringify({ line: app.logs[index] })}
+
+`);
+            index++;
+          }
+        }, 500);
+      },
+      cancel() {
+        if (interval) clearInterval(interval);
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache"
+      }
+    });
+  });
+  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) => {
+    if (config.webhookSecret) {
+      const sig = req.headers.get("x-hub-signature-256") ?? "";
+      const body = await req.clone().text();
+      const hmac = crypto4.createHmac("sha256", config.webhookSecret).update(body).digest("hex");
+      if (sig !== `sha256=${hmac}`) {
+        return Response.json({ error: "invalid signature" }, { status: 401 });
+      }
+    }
+    const payload = await req.json();
+    const repoUrl = payload?.repository?.clone_url ?? payload?.repository?.html_url ?? "";
+    if (!repoUrl) return Response.json({ deployed: [] });
+    const deployed = [];
+    for (const [name15] of apps) {
+      const ac = apps.get(name15)?.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(name15);
+        deployed.push(name15);
+      }
+    }
+    return Response.json({ deployed });
+  });
+  return router;
+}
+
+// deploy/process.ts
+import { fork } from "node:child_process";
+function forkApp(opts) {
+  const child = fork(opts.entry, [], {
+    cwd: opts.cwd,
+    env: {
+      ...process.env,
+      ...opts.env,
+      PORT: String(opts.port)
+    },
+    stdio: ["pipe", "pipe", "pipe", "ipc"]
+  });
+  child.stdout?.on("data", (chunk) => {
+    for (const line of chunk.toString().split("\n").filter(Boolean)) {
+      opts.onLog?.(line);
+    }
+  });
+  child.stderr?.on("data", (chunk) => {
+    for (const line of chunk.toString().split("\n").filter(Boolean)) {
+      opts.onLog?.(`[error] ${line}`);
+    }
+  });
+  return { child, port: opts.port };
+}
+function stopProcess(mp, timeout = 1e4) {
+  return new Promise((resolve3) => {
+    const timer = setTimeout(() => {
+      mp.child.kill("SIGKILL");
+      resolve3();
+    }, timeout);
+    mp.child.on("exit", () => {
+      clearTimeout(timer);
+      resolve3();
+    });
+    mp.child.kill("SIGTERM");
+  });
+}
+async function healthCheck(port, path2 = "/") {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}${path2}`, {
+      signal: AbortSignal.timeout(5e3)
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+// 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 [name15, app] of Object.entries(config.apps)) {
+    if (!app.repo) throw new Error(`deploy: app "${name15}" has no repo`);
+    if (!app.entry) throw new Error(`deploy: app "${name15}" has no entry`);
+    if (!app.port) throw new Error(`deploy: app "${name15}" has no port`);
+  }
+  return {
+    port: config.port ?? 80,
+    appsDir: config.appsDir ?? "/opt/weifuwu/apps",
+    ...config
+  };
+}
+
+// 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) {
+    try {
+      const mp = forkApp({ cwd, entry, port, env, onLog });
+      onLog(`[deploy] forked 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");
+      return mp;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      onLog(`[deploy] fork error: ${msg}`);
+      return null;
+    }
+  }
+  function scheduleRestart(name15, runtime) {
+    const delay = Math.min(1e3 * Math.pow(2, runtime.restartCount), 3e4);
+    runtime.restartCount++;
+    runtime.logs.push(`[deploy] auto-restart in ${delay}ms (attempt ${runtime.restartCount})`);
+    runtime.restartTimer = setTimeout(() => initApp(name15), delay);
+  }
+  async function initApp(name15) {
+    const ac = config.apps[name15];
+    if (!ac) return;
+    const old = apps.get(name15);
+    if (old?.restartTimer) {
+      clearTimeout(old.restartTimer);
+      old.restartTimer = void 0;
+    }
+    const appDir = path.join(appsDir, name15);
+    const logs = [];
+    const log = (line) => {
+      logs.push(line);
+      if (logs.length > 1e3) logs.splice(0, logs.length - 1e3);
+    };
+    try {
+      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 ${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(name15, ac, logs, { status: "error", port: ac.port, error: msg });
+      log(`[deploy] git error: ${msg}`);
+      if (old?.process) {
+        apps.set(name15, 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(name15, ac, logs, { status: "error", port: ac.port, error: msg });
+      log(`[deploy] npm install error: ${msg}`);
+      if (old?.process) apps.set(name15, old);
+      return;
+    }
+    if (ac.buildCommand) {
+      try {
+        execSync(ac.buildCommand, { cwd: appDir, stdio: "pipe", timeout: 12e4 });
+        log("[deploy] build done");
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        setAppRuntime(name15, ac, logs, { status: "error", port: ac.port, error: msg });
+        log(`[deploy] build error: ${msg}`);
+        if (old?.process) apps.set(name15, old);
+        return;
+      }
+    }
+    let targetPort = ac.port;
+    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);
+    if (!mp) {
+      log("[deploy] new process failed to start, keeping old running");
+      if (old?.process) apps.set(name15, old);
+      else {
+        setAppRuntime(name15, ac, logs, { status: "error", port: targetPort, error: "failed to start" });
+      }
+      return;
+    }
+    const runtime = {
+      config: ac,
+      status: { name: name15, status: "running", port: targetPort, subdomain: ac.subdomain, path: ac.path, pid: mp.child.pid ?? void 0 },
+      logs,
+      process: mp.child,
+      currentPort: targetPort,
+      startedAt: Date.now(),
+      restartCount: 0,
+      restartTimer: void 0
+    };
+    apps.set(name15, runtime);
+    mp.child.on("exit", (code, signal) => {
+      runtime.process = null;
+      runtime.status = {
+        ...runtime.status,
+        status: "error",
+        error: `exited (code=${code} signal=${signal})`,
+        pid: void 0
+      };
+      log(`[deploy] process exited code=${code} signal=${signal}`);
+      if (code !== 0 && signal !== "SIGTERM") {
+        scheduleRestart(name15, runtime);
+      }
+    });
+    if (old?.process && old.currentPort !== targetPort) {
+      if (old.restartTimer) clearTimeout(old.restartTimer);
+      log(`[deploy] stopping old process on port ${old.currentPort}`);
+      await stopProcess({ child: old.process, port: old.currentPort });
+    }
+  }
+  function setAppRuntime(name15, ac, logs, overrides) {
+    apps.set(name15, {
+      config: ac,
+      status: { name: name15, ...overrides },
+      logs,
+      process: null,
+      currentPort: overrides.port ?? ac.port,
+      startedAt: null,
+      restartCount: 0,
+      restartTimer: void 0
+    });
+  }
+  for (const name15 of Object.keys(config.apps)) {
+    await initApp(name15);
+  }
+  const getPort = (name15) => apps.get(name15)?.currentPort;
+  const gw = createGateway(config, getPort);
+  const managerRouter = createManager(config, apps, {
+    deployApp: async (name15) => {
+      await initApp(name15);
+    },
+    reloadConfig: async () => {
+      throw new Error("reload not supported, restart the deploy process");
+    }
+  });
+  const fullHandler = async (req, ctx) => {
+    const url = new URL(req.url);
+    if (url.pathname.startsWith("/_deploy")) {
+      const stripped = url.pathname.replace("/_deploy", "") || "/";
+      const rewritten = new URL(stripped + url.search, "http://deploy.local");
+      const rewrittenReq = new Request(rewritten, req);
+      return managerRouter.handler()(rewrittenReq, ctx);
+    }
+    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 {
+    stop: async () => {
+      for (const [, app] of apps) {
+        if (app.restartTimer) clearTimeout(app.restartTimer);
+        if (app.process) {
+          await stopProcess({ child: app.process, port: app.currentPort });
+        }
+      }
+      httpServer?.stop();
+    },
+    ready: httpServer.ready,
+    url: `http://${config.domain}${portSuffix}`,
+    apps: {
+      list: () => Array.from(apps.values()).map((a) => a.status),
+      status: (name15) => apps.get(name15)?.status,
+      deploy: async (name15) => {
+        await initApp(name15);
+      },
+      restart: async (name15) => {
+        await initApp(name15);
+      },
+      stop: async (name15) => {
+        const app = apps.get(name15);
+        if (app?.restartTimer) clearTimeout(app.restartTimer);
+        if (app?.process) {
+          await stopProcess({ child: app.process, port: app.currentPort });
+          app.process = null;
+          app.status = { ...app.status, status: "stopped", pid: void 0 };
+        }
+      },
+      start: async (name15) => {
+        await initApp(name15);
+      }
+    }
+  };
+}
+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 }
+  );
+}
 export {
   Router,
   TsxContext,
@@ -24638,7 +25212,9 @@ export {
   cors,
   createSSEManager,
   createWorkflowEngine,
+  defineConfig,
   deleteCookie,
+  deploy,
   generateWorkflow,
   getCookies,
   graphql,

package/dist/serve.d.ts

@@ -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

@@ -1,6 +1,6 @@
 {
   "name": "weifuwu",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "Web-standard HTTP framework for Node.js — (req, ctx) => Response",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",