@dyyz1993/create-agent 2.0.0 → 2.0.1

package/templates/general/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/general/src/shared/lib/__tests__/logger.test.ts

@@ -0,0 +1,92 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdirSync, existsSync, readdirSync, readFileSync, writeFileSync, rmSync, utimesSync } from "fs";
+import { join } from "path";
+
+const TEST_LOG_DIR = join(process.cwd(), "test-logs");
+
+describe("Logger", () => {
+  beforeEach(async () => {
+    if (existsSync(TEST_LOG_DIR)) {
+      rmSync(TEST_LOG_DIR, { recursive: true, force: true });
+    }
+    mkdirSync(TEST_LOG_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(TEST_LOG_DIR)) {
+      rmSync(TEST_LOG_DIR, { recursive: true, force: true });
+    }
+  });
+
+  it("should write logs asynchronously", async () => {
+    const { createLogger, configureLogDir, flushLogs } = await import("../logger");
+    await configureLogDir(TEST_LOG_DIR);
+
+    const logger = createLogger("test");
+    logger.info("test message");
+
+    await flushLogs();
+    await new Promise((r) => setTimeout(r, 100));
+
+    const files = readdirSync(TEST_LOG_DIR);
+    expect(files.length).toBeGreaterThan(0);
+
+    const content = readFileSync(join(TEST_LOG_DIR, files[0]), "utf-8");
+    expect(content).toContain("test message");
+  });
+
+  it("should support multiple log levels", async () => {
+    const { createLogger, configureLogDir, flushLogs } = await import("../logger");
+    await configureLogDir(TEST_LOG_DIR);
+
+    const logger = createLogger("test");
+    logger.debug("debug msg");
+    logger.info("info msg");
+    logger.warn("warn msg");
+    logger.error("error msg");
+
+    await flushLogs();
+
+    const files = readdirSync(TEST_LOG_DIR);
+    const content = readFileSync(join(TEST_LOG_DIR, files[0]), "utf-8");
+    expect(content).toContain("info msg");
+    expect(content).toContain("warn msg");
+    expect(content).toContain("error msg");
+  });
+
+  it("should clean up old log files based on maxAgeDays", async () => {
+    const { configureLogDir } = await import("../logger");
+
+    const oldDate = new Date(Date.now() - 10 * 86400000).toISOString().slice(0, 10);
+    const oldPath = join(TEST_LOG_DIR, `${oldDate}.log`);
+    writeFileSync(oldPath, "old log");
+    const oldTime = new Date(Date.now() - 10 * 86400000);
+    utimesSync(oldPath, oldTime, oldTime);
+
+    const todayFile = new Date().toISOString().slice(0, 10);
+    writeFileSync(join(TEST_LOG_DIR, `${todayFile}.log`), "today log");
+
+    await configureLogDir(TEST_LOG_DIR, { maxAgeDays: 5 });
+
+    const files = readdirSync(TEST_LOG_DIR);
+    expect(files.find((f) => f.includes(oldDate))).toBeUndefined();
+    expect(files.find((f) => f.includes(todayFile))).toBeDefined();
+  });
+
+  it("should flush all pending writes", async () => {
+    const { createLogger, configureLogDir, flushLogs } = await import("../logger");
+    await configureLogDir(TEST_LOG_DIR);
+
+    const logger = createLogger("test");
+    for (let i = 0; i < 100; i++) {
+      logger.info(`msg ${i}`);
+    }
+
+    await flushLogs();
+
+    const files = readdirSync(TEST_LOG_DIR);
+    const content = readFileSync(join(TEST_LOG_DIR, files[0]), "utf-8");
+    expect(content).toContain("msg 0");
+    expect(content).toContain("msg 99");
+  });
+});

package/templates/general/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);
 }