@dyyz1993/create-agent 2.0.0 → 2.0.1

package/templates/agent/src/shared/http-routes.ts

@@ -0,0 +1,250 @@
+/**
+ * HTTP route handlers for the web gateway.
+ * Handles: /health, /info/{path}, /file/{path}, /file/upload
+ */
+
+import type { IncomingMessage, ServerResponse } from "http";
+import { stat, readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { extname, basename, dirname, resolve } from "path";
+import { timingSafeEqual } from "crypto";
+import { createLogger } from "./lib/logger";
+
+const log = createLogger("gateway");
+
+function safeEqual(a: string, b: string): boolean {
+	const bufA = Buffer.from(a);
+	const bufB = Buffer.from(b);
+	if (bufA.length !== bufB.length) return false;
+	return timingSafeEqual(bufA, bufB);
+}
+
+const MIME_TYPES: Record<string, string> = {
+	".html": "text/html",
+	".css": "text/css",
+	".js": "application/javascript",
+	".json": "application/json",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".svg": "image/svg+xml",
+	".ico": "image/x-icon",
+	".txt": "text/plain",
+	".md": "text/markdown",
+	".ts": "text/plain",
+	".tsx": "text/plain",
+	".py": "text/plain",
+	".pdf": "application/pdf",
+	".zip": "application/zip",
+	".mp4": "video/mp4",
+	".mp3": "audio/mpeg",
+	".wav": "audio/wav",
+};
+
+const ALLOWED_ROOTS = [resolve(process.cwd())];
+function isPathAllowed(requestedPath: string): boolean {
+	const resolved = resolve(requestedPath);
+	return ALLOWED_ROOTS.some((root) => resolved === root || resolved.startsWith(root + "/"));
+}
+
+function verifyToken(req: IncomingMessage, authToken: string): boolean {
+	const auth = req.headers["authorization"];
+	if (auth && safeEqual(auth, `Bearer ${authToken}`)) return true;
+
+	if (req.url) {
+		try {
+			const url = new URL(req.url, "http://localhost");
+			const token = url.searchParams.get("token");
+			if (token && safeEqual(token, authToken)) return true;
+		} catch {
+			/* invalid URL */
+		}
+	}
+	return false;
+}
+
+export interface HttpRouteDeps {
+	config: {
+		readonly port: number;
+		readonly authToken: string;
+		readonly maxUploadSize: number;
+		readonly corsOrigin: string;
+	};
+	getWebSocketClientCount: () => number;
+}
+
+export function createHttpHandler(
+	deps: HttpRouteDeps
+): (req: IncomingMessage, res: ServerResponse) => void {
+	const { config: cfg, getWebSocketClientCount } = deps;
+
+	return async (req, res) => {
+		res.setHeader("Access-Control-Allow-Origin", cfg.corsOrigin);
+		res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+		res.setHeader("Access-Control-Allow-Headers", "Authorization, Range, Content-Type");
+		if (req.method === "OPTIONS") {
+			res.writeHead(204).end();
+			return;
+		}
+
+		if (!req.url) {
+			res.writeHead(400).end();
+			return;
+		}
+
+		const url = new URL(req.url, "http://localhost");
+
+		if (url.pathname === "/health") {
+			res.writeHead(200, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ status: "ok", clients: getWebSocketClientCount() }));
+			return;
+		}
+
+		if (!verifyToken(req, cfg.authToken)) {
+			log.warn("Auth failed", { path: url.pathname });
+			res.writeHead(401, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: "Unauthorized" }));
+			return;
+		}
+
+		if (url.pathname.startsWith("/info/")) {
+			await handleFileInfo(url.pathname.slice(6), res);
+			return;
+		}
+
+		if (url.pathname.startsWith("/file/")) {
+			if (url.pathname === "/file/upload" && req.method === "POST") {
+				await handleFileUpload(req, url.searchParams.get("path"), res, cfg.maxUploadSize);
+				return;
+			}
+			await handleFileContent(url.pathname.slice(6), req, res);
+			return;
+		}
+
+		res.writeHead(404);
+		res.end();
+	};
+}
+
+async function handleFileInfo(encodedPath: string, res: ServerResponse): Promise<void> {
+	const filePath = decodeURIComponent(encodedPath);
+	if (!isPathAllowed(filePath)) {
+		res.writeHead(403, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({ error: "Path not allowed" }));
+		return;
+	}
+	try {
+		const s = await stat(filePath);
+		res.writeHead(200, { "Content-Type": "application/json" });
+		res.end(
+			JSON.stringify({
+				name: basename(filePath),
+				path: filePath,
+				size: s.size,
+				isDirectory: s.isDirectory(),
+				modified: s.mtime.toISOString(),
+				mimeType: s.isFile()
+					? MIME_TYPES[extname(filePath)] || "application/octet-stream"
+					: undefined,
+			})
+		);
+	} catch {
+		res.writeHead(404, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({ error: "File not found" }));
+	}
+}
+
+async function handleFileContent(
+	encodedPath: string,
+	req: IncomingMessage,
+	res: ServerResponse
+): Promise<void> {
+	const filePath = decodeURIComponent(encodedPath);
+	if (!isPathAllowed(filePath)) {
+		res.writeHead(403, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({ error: "Path not allowed" }));
+		return;
+	}
+	try {
+		if (!existsSync(filePath)) {
+			res.writeHead(404, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: "File not found" }));
+			return;
+		}
+		const s = await stat(filePath);
+		const mimeType = MIME_TYPES[extname(filePath)] || "application/octet-stream";
+
+		const range = req.headers["range"];
+		if (range) {
+			const parts = range.replace(/bytes=/, "").split("-");
+			const start = parseInt(parts[0], 10);
+			const end = parts[1] ? parseInt(parts[1], 10) : s.size - 1;
+			const chunkSize = end - start + 1;
+
+			res.writeHead(206, {
+				"Content-Range": `bytes ${start}-${end}/${s.size}`,
+				"Accept-Ranges": "bytes",
+				"Content-Length": chunkSize,
+				"Content-Type": mimeType,
+			});
+			const buffer = await readFile(filePath);
+			res.end(buffer.subarray(start, end + 1));
+		} else {
+			res.writeHead(200, {
+				"Content-Length": s.size,
+				"Content-Type": mimeType,
+				"Accept-Ranges": "bytes",
+			});
+			const buffer = await readFile(filePath);
+			res.end(buffer);
+		}
+		log.info("File served", { path: filePath });
+	} catch {
+		res.writeHead(500, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({ error: "Failed to read file" }));
+	}
+}
+
+async function handleFileUpload(
+	req: IncomingMessage,
+	destPath: string | null,
+	res: ServerResponse,
+	maxUploadSize: number
+): Promise<void> {
+	if (!destPath) {
+		res.writeHead(400, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({ error: "Missing path parameter" }));
+		return;
+	}
+	if (!isPathAllowed(destPath)) {
+		res.writeHead(403, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({ error: "Path not allowed" }));
+		return;
+	}
+	const contentLength = parseInt(req.headers["content-length"] || "0", 10);
+	if (contentLength > maxUploadSize) {
+		res.writeHead(413, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({ error: `File too large, max ${maxUploadSize / 1024 / 1024}MB` }));
+		return;
+	}
+	try {
+		const chunks: Uint8Array[] = [];
+		for await (const chunk of req) {
+			const bytes =
+				typeof chunk === "string"
+					? new TextEncoder().encode(chunk)
+					: new Uint8Array(chunk as ArrayBuffer);
+			chunks.push(bytes);
+		}
+		const body = Buffer.concat(chunks);
+		await mkdir(dirname(destPath), { recursive: true });
+		await writeFile(destPath, body);
+		log.info("File uploaded", { path: destPath, size: body.length });
+		res.writeHead(200, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({ ok: true, path: destPath, size: body.length }));
+	} catch (err) {
+		res.writeHead(500, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({ error: err instanceof Error ? err.message : "Upload failed" }));
+	}
+}

package/templates/agent/src/shared/lib/__tests__/web-server.test.ts

@@ -0,0 +1,190 @@
+import { describe, it, expect, afterEach } from "vitest";
+import http from "http";
+import { WebSocket } from "ws";
+import {
+	createWebServer,
+	getLocalIP,
+	findAvailablePort,
+	type WebServerResult,
+} from "../web-server";
+
+function httpGet(url: string): Promise<{ status: number; body: string }> {
+	return new Promise((resolve, reject) => {
+		http
+			.get(url, (res) => {
+				let data = "";
+				res.on("data", (chunk) => {
+					data += chunk;
+				});
+				res.on("end", () => resolve({ status: res.statusCode ?? 0, body: data }));
+			})
+			.on("error", reject);
+	});
+}
+
+describe("createWebServer 工厂函数", () => {
+	let webServer: WebServerResult | null = null;
+
+	afterEach(async () => {
+		if (webServer) {
+			await webServer.close();
+			webServer = null;
+		}
+	});
+
+	it("应返回 httpServer + wss + port + authToken", async () => {
+		webServer = await createWebServer({
+			port: 0,
+			authToken: "test-token-001",
+			maxUploadSize: 1024,
+			corsOrigin: "*",
+		});
+
+		expect(webServer.httpServer).toBeDefined();
+		expect(webServer.wss).toBeDefined();
+		expect(webServer.port).toBeGreaterThan(0);
+		expect(webServer.authToken).toBe("test-token-001");
+		expect(typeof webServer.close).toBe("function");
+	});
+
+	it("应启动 HTTP 服务并监听指定端口", async () => {
+		const testServer = http.createServer();
+		const port = await new Promise<number>((resolve) => {
+			testServer.listen(0, () => {
+				const addr = testServer.address();
+				resolve(typeof addr === "object" && addr ? addr.port : 3100);
+			});
+		});
+		await new Promise<void>((resolve) => testServer.close(() => resolve()));
+
+		webServer = await createWebServer({
+			port,
+			authToken: "test-token-002",
+			maxUploadSize: 1024,
+			corsOrigin: "*",
+		});
+
+		expect(webServer.port).toBe(port);
+
+		const { status, body } = await httpGet(`http://localhost:${webServer.port}/health`);
+		expect(status).toBe(200);
+		const json = JSON.parse(body);
+		expect(json.status).toBe("ok");
+	});
+
+	it("端口冲突时应自动递增到可用端口", async () => {
+		const blocker = http.createServer();
+		const blockerPort = await new Promise<number>((resolve) => {
+			blocker.listen(0, () => {
+				const addr = blocker.address();
+				resolve(typeof addr === "object" && addr ? addr.port : 3100);
+			});
+		});
+
+		webServer = await createWebServer({
+			port: blockerPort,
+			authToken: "test-token-003",
+			maxUploadSize: 1024,
+			corsOrigin: "*",
+		});
+
+		expect(webServer.port).not.toBe(blockerPort);
+		expect(webServer.port).toBeGreaterThan(blockerPort);
+
+		await new Promise<void>((resolve) => blocker.close(() => resolve()));
+	});
+
+	it("WS 客户端应能通过 token 连接", async () => {
+		webServer = await createWebServer({
+			port: 0,
+			authToken: "test-token-004",
+			maxUploadSize: 1024,
+			corsOrigin: "*",
+		});
+
+		const ws = new WebSocket(`ws://localhost:${webServer.port}/ws?token=${webServer.authToken}`);
+
+		await new Promise<void>((resolve, reject) => {
+			ws.on("open", () => {
+				ws.close();
+				resolve();
+			});
+			ws.on("error", reject);
+		});
+	});
+
+	it("无 token 的 WS 连接应被拒绝", async () => {
+		webServer = await createWebServer({
+			port: 0,
+			authToken: "test-token-005",
+			maxUploadSize: 1024,
+			corsOrigin: "*",
+		});
+
+		const ws = new WebSocket(`ws://localhost:${webServer.port}/ws`);
+
+		const closeCode = await new Promise<number>((resolve) => {
+			ws.on("close", (code) => resolve(code));
+			ws.on("error", () => {});
+		});
+		expect(closeCode).toBe(4001);
+	});
+
+	it("HTTP 请求需要 token 才能访问文件路由", async () => {
+		webServer = await createWebServer({
+			port: 0,
+			authToken: "test-token-006",
+			maxUploadSize: 1024,
+			corsOrigin: "*",
+		});
+
+		const { status } = await httpGet(`http://localhost:${webServer.port}/info/some/path`);
+		expect(status).toBe(401);
+	});
+
+	it("health 端点不需要 token", async () => {
+		webServer = await createWebServer({
+			port: 0,
+			authToken: "test-token-007",
+			maxUploadSize: 1024,
+			corsOrigin: "*",
+		});
+
+		const { status, body } = await httpGet(`http://localhost:${webServer.port}/health`);
+		expect(status).toBe(200);
+		const json = JSON.parse(body);
+		expect(json).toHaveProperty("status", "ok");
+		expect(json).toHaveProperty("clients");
+	});
+
+	it("关闭 webServer 应停止 HTTP 和 WS 服务", async () => {
+		webServer = await createWebServer({
+			port: 0,
+			authToken: "test-token-008",
+			maxUploadSize: 1024,
+			corsOrigin: "*",
+		});
+
+		const port = webServer.port;
+		await webServer.close();
+		webServer = null;
+
+		await expect(httpGet(`http://localhost:${port}/health`)).rejects.toThrow();
+	});
+});
+
+describe("getLocalIP", () => {
+	it("应返回非空字符串", () => {
+		const ip = getLocalIP();
+		expect(typeof ip).toBe("string");
+		expect(ip.length).toBeGreaterThan(0);
+		expect(ip).toMatch(/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/);
+	});
+});
+
+describe("findAvailablePort", () => {
+	it("应返回一个可用端口", async () => {
+		const port = await findAvailablePort(40000);
+		expect(port).toBeGreaterThanOrEqual(40000);
+	});
+});

package/templates/agent/src/shared/lib/logger.ts

@@ -1,130 +1,152 @@
-import { appendFile, mkdir as mkdirAsync, readdir as readdirAsync, unlink as unlinkAsync, stat as statAsync } from "fs/promises";
+import {
+	appendFile,
+	mkdir as mkdirAsync,
+	readdir as readdirAsync,
+	unlink as unlinkAsync,
+	stat as statAsync,
+} from "fs/promises";
 import { mkdirSync, existsSync } from "fs";
 import { join } from "path";
 
-export type LogModule = "server" | "gateway" | "system" | "chat" | "file" | "timer" | "git" | "feed";
+export type LogModule =
+	| "server"
+	| "gateway"
+	| "system"
+	| "chat"
+	| "file"
+	| "timer"
+	| "git"
+	| "feed"
+	| "web-server";
 type LogLevel = "debug" | "info" | "warn" | "error";
 
 interface LogEntry {
-  timestamp: string;
-  level: LogLevel;
-  module: LogModule;
-  message: string;
-  data?: Record<string, unknown>;
+	timestamp: string;
+	level: LogLevel;
+	module: LogModule;
+	message: string;
+	data?: Record<string, unknown>;
 }
 
 let _logDir: string | null = null;
 let _maxAgeDays = 30;
 
-export async function configureLogDir(dir: string, options?: { maxAgeDays?: number }): Promise<void> {
-  _logDir = dir;
-  if (options?.maxAgeDays !== undefined) {
-    _maxAgeDays = options.maxAgeDays;
-  }
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  await cleanOldLogs(dir, _maxAgeDays);
+export async function configureLogDir(
+	dir: string,
+	options?: { maxAgeDays?: number }
+): Promise<void> {
+	_logDir = dir;
+	if (options?.maxAgeDays !== undefined) {
+		_maxAgeDays = options.maxAgeDays;
+	}
+	if (!existsSync(dir)) {
+		mkdirSync(dir, { recursive: true });
+	}
+	await cleanOldLogs(dir, _maxAgeDays);
 }
 
 function getLogDir(): string {
-  if (!_logDir) {
-    _logDir = "logs";
-    if (!existsSync(_logDir)) {
-      mkdirSync(_logDir, { recursive: true });
-    }
-  }
-  return _logDir;
+	if (!_logDir) {
+		_logDir = "logs";
+		if (!existsSync(_logDir)) {
+			mkdirSync(_logDir, { recursive: true });
+		}
+	}
+	return _logDir;
 }
 
 async function cleanOldLogs(dir: string, maxAgeDays: number): Promise<void> {
-  try {
-    if (!existsSync(dir)) return;
-    const files = await readdirAsync(dir);
-    const cutoff = Date.now() - maxAgeDays * 86400000;
-    for (const f of files) {
-      if (!f.endsWith(".log")) continue;
-      const filePath = join(dir, f);
-      const s = await statAsync(filePath);
-      if (s.mtimeMs < cutoff) {
-        await unlinkAsync(filePath);
-      }
-    }
-  } catch { /* ignore */ }
+	try {
+		if (!existsSync(dir)) return;
+		const files = await readdirAsync(dir);
+		const cutoff = Date.now() - maxAgeDays * 86400000;
+		for (const f of files) {
+			if (!f.endsWith(".log")) continue;
+			const filePath = join(dir, f);
+			const s = await statAsync(filePath);
+			if (s.mtimeMs < cutoff) {
+				await unlinkAsync(filePath);
+			}
+		}
+	} catch {
+		/* ignore */
+	}
 }
 
 function formatLine(entry: LogEntry): string {
-  const base = `[${entry.timestamp}] [${entry.level.toUpperCase()}] [${entry.module}] ${entry.message}`;
-  return entry.data ? `${base} ${JSON.stringify(entry.data)}` : base;
+	const base = `[${entry.timestamp}] [${entry.level.toUpperCase()}] [${entry.module}] ${entry.message}`;
+	return entry.data ? `${base} ${JSON.stringify(entry.data)}` : base;
 }
 
 let writeQueue: Promise<void> = Promise.resolve();
 
 function writeToFile(line: string): void {
-  writeQueue = writeQueue.then(async () => {
-    try {
-      const date = new Date().toISOString().slice(0, 10);
-      const dir = getLogDir();
-      if (!existsSync(dir)) {
-        await mkdirAsync(dir, { recursive: true });
-      }
-      await appendFile(join(dir, `${date}.log`), `${line}\n`);
-    } catch { /* ignore */ }
-  });
+	writeQueue = writeQueue.then(async () => {
+		try {
+			const date = new Date().toISOString().slice(0, 10);
+			const dir = getLogDir();
+			if (!existsSync(dir)) {
+				await mkdirAsync(dir, { recursive: true });
+			}
+			await appendFile(join(dir, `${date}.log`), `${line}\n`);
+		} catch {
+			/* ignore */
+		}
+	});
 }
 
 export function flushLogs(): Promise<void> {
-  return writeQueue;
+	return writeQueue;
 }
 
 export class Logger {
-  private readonly module: LogModule;
-
-  constructor(module: LogModule) {
-    this.module = module;
-  }
-
-  debug(message: string, data?: Record<string, unknown>): void {
-    this.write("debug", message, data);
-  }
-
-  info(message: string, data?: Record<string, unknown>): void {
-    this.write("info", message, data);
-  }
-
-  warn(message: string, data?: Record<string, unknown>): void {
-    this.write("warn", message, data);
-  }
-
-  error(message: string, data?: Record<string, unknown>): void {
-    this.write("error", message, data);
-  }
-
-  private write(level: LogLevel, message: string, data?: Record<string, unknown>): void {
-    const entry: LogEntry = {
-      timestamp: new Date().toISOString(),
-      level,
-      module: this.module,
-      message,
-      ...(data ? { data } : {}),
-    };
-
-    const line = formatLine(entry);
-
-    if (level === "error") {
-      console.error(line);
-    } else if (level === "warn") {
-      console.warn(line);
-    } else {
-      console.log(line);
-    }
-
-    if (process.env.NODE_ENV !== "production" || level !== "debug") {
-      writeToFile(line);
-    }
-  }
+	private readonly module: LogModule;
+
+	constructor(module: LogModule) {
+		this.module = module;
+	}
+
+	debug(message: string, data?: Record<string, unknown>): void {
+		this.write("debug", message, data);
+	}
+
+	info(message: string, data?: Record<string, unknown>): void {
+		this.write("info", message, data);
+	}
+
+	warn(message: string, data?: Record<string, unknown>): void {
+		this.write("warn", message, data);
+	}
+
+	error(message: string, data?: Record<string, unknown>): void {
+		this.write("error", message, data);
+	}
+
+	private write(level: LogLevel, message: string, data?: Record<string, unknown>): void {
+		const entry: LogEntry = {
+			timestamp: new Date().toISOString(),
+			level,
+			module: this.module,
+			message,
+			...(data ? { data } : {}),
+		};
+
+		const line = formatLine(entry);
+
+		if (level === "error") {
+			console.error(line);
+		} else if (level === "warn") {
+			console.warn(line);
+		} else {
+			console.log(line);
+		}
+
+		if (process.env.NODE_ENV !== "production" || level !== "debug") {
+			writeToFile(line);
+		}
+	}
 }
 
 export function createLogger(module: LogModule): Logger {
-  return new Logger(module);
+	return new Logger(module);
 }