weifuwu 0.7.0 → 0.8.0

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

@@ -10918,38 +10918,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 +10964,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);
@@ -11026,8 +11026,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;
@@ -12192,9 +12192,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 +12204,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 +12222,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("$")) {
@@ -23884,37 +23884,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 +23929,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-"]
@@ -24628,6 +24628,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 +25172,9 @@ export {
   cors,
   createSSEManager,
   createWorkflowEngine,
+  defineConfig,
   deleteCookie,
+  deploy,
   generateWorkflow,
   getCookies,
   graphql,

package/package.json

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