@dyyz1993/create-agent 2.0.0 → 2.0.1

package/templates/shared/__tests__/http-routes.test.ts

@@ -0,0 +1,174 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+function mockRes() {
+	const state = { statusCode: 200, body: "", headers: {} as Record<string, string> };
+
+	const res = {
+		setHeader(key: string, val: string) {
+			state.headers[key] = val;
+		},
+		writeHead(code: number, hdrs?: Record<string, string>) {
+			state.statusCode = code;
+			if (hdrs) Object.assign(state.headers, hdrs);
+			return res;
+		},
+		end(data?: string) {
+			if (data !== undefined) state.body = data;
+		},
+	};
+
+	return { res, state };
+}
+
+function mockReq(url: string, opts?: { method?: string; headers?: Record<string, string> }) {
+	return {
+		url,
+		method: opts?.method ?? "GET",
+		headers: {
+			"content-length": "0",
+			...opts?.headers,
+		},
+		[Symbol.asyncIterator]() {
+			return { next: () => Promise.resolve({ done: true }) };
+		},
+	};
+}
+
+const config = {
+	port: 3000,
+	authToken: "test-token",
+	maxUploadSize: 1024 * 1024 * 10,
+	corsOrigin: "*",
+};
+
+describe("HTTP Routes (shared)", () => {
+	beforeEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	it("/health returns ok status", async () => {
+		const { createHttpHandler } = await import("../http-routes");
+		const handler = createHttpHandler({
+			config,
+			getWebSocketClientCount: () => 3,
+		});
+
+		const { res, state } = mockRes();
+		await handler(mockReq("/health"), res);
+
+		expect(state.statusCode).toBe(200);
+		const parsed = JSON.parse(state.body);
+		expect(parsed.status).toBe("ok");
+		expect(parsed.clients).toBe(3);
+	});
+
+	it("returns 401 without auth token", async () => {
+		const { createHttpHandler } = await import("../http-routes");
+		const handler = createHttpHandler({
+			config,
+			getWebSocketClientCount: () => 0,
+		});
+
+		const { res, state } = mockRes();
+		await handler(mockReq("/file/test.txt"), res);
+
+		expect(state.statusCode).toBe(401);
+		expect(JSON.parse(state.body).error).toBe("Unauthorized");
+	});
+
+	it("accepts Bearer token in Authorization header", async () => {
+		const { createHttpHandler } = await import("../http-routes");
+		const handler = createHttpHandler({
+			config,
+			getWebSocketClientCount: () => 0,
+		});
+
+		const { res, state } = mockRes();
+		await handler(
+			mockReq("/info/nonexistent", {
+				headers: { authorization: "Bearer test-token" },
+			}),
+			res
+		);
+
+		expect(state.statusCode).not.toBe(401);
+	});
+
+	it("accepts token in query parameter", async () => {
+		const { createHttpHandler } = await import("../http-routes");
+		const handler = createHttpHandler({
+			config,
+			getWebSocketClientCount: () => 0,
+		});
+
+		const { res, state } = mockRes();
+		await handler(mockReq("/info/nonexistent?token=test-token"), res);
+
+		expect(state.statusCode).not.toBe(401);
+	});
+
+	it("handles CORS preflight OPTIONS", async () => {
+		const { createHttpHandler } = await import("../http-routes");
+		const handler = createHttpHandler({
+			config,
+			getWebSocketClientCount: () => 0,
+		});
+
+		const { res, state } = mockRes();
+		await handler(mockReq("/health", { method: "OPTIONS" }), res);
+
+		expect(state.statusCode).toBe(204);
+		expect(state.headers["Access-Control-Allow-Origin"]).toBe("*");
+	});
+
+	it("returns 400 for request without url", async () => {
+		const { createHttpHandler } = await import("../http-routes");
+		const handler = createHttpHandler({
+			config,
+			getWebSocketClientCount: () => 0,
+		});
+
+		const { res, state } = mockRes();
+		await handler({ method: "GET", headers: {} }, res);
+
+		expect(state.statusCode).toBe(400);
+	});
+
+	it("returns 404 for unknown routes", async () => {
+		const { createHttpHandler } = await import("../http-routes");
+		const handler = createHttpHandler({
+			config,
+			getWebSocketClientCount: () => 0,
+		});
+
+		const { res, state } = mockRes();
+		await handler(
+			mockReq("/unknown", {
+				headers: { authorization: "Bearer test-token" },
+			}),
+			res
+		);
+
+		expect(state.statusCode).toBe(404);
+	});
+
+	it("/file/upload without path returns 400", async () => {
+		const { createHttpHandler } = await import("../http-routes");
+		const handler = createHttpHandler({
+			config,
+			getWebSocketClientCount: () => 0,
+		});
+
+		const { res, state } = mockRes();
+		await handler(
+			mockReq("/file/upload", {
+				method: "POST",
+				headers: { authorization: "Bearer test-token" },
+			}),
+			res
+		);
+
+		expect(state.statusCode).toBe(400);
+		expect(JSON.parse(state.body).error).toContain("Missing path");
+	});
+});

package/templates/shared/__tests__/logger.test.ts

@@ -0,0 +1,186 @@
+import { describe, it, expect, beforeEach, afterEach, vi } 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-shared");
+
+describe("Logger (shared)", () => {
+	beforeEach(async () => {
+		vi.restoreAllMocks();
+		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 to file asynchronously", async () => {
+		const { createLogger, configureLogDir, flushLogs } = await import("../logger");
+		configureLogDir(TEST_LOG_DIR);
+
+		const logger = createLogger("test-module");
+		logger.info("hello world");
+
+		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("hello world");
+		expect(content).toContain("[test-module]");
+		expect(content).toContain("[INFO]");
+	});
+
+	it("should support all log levels", async () => {
+		const { createLogger, configureLogDir, flushLogs } = await import("../logger");
+		configureLogDir(TEST_LOG_DIR);
+
+		const logger = createLogger("levels");
+		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("[DEBUG]");
+		expect(content).toContain("[INFO]");
+		expect(content).toContain("[WARN]");
+		expect(content).toContain("[ERROR]");
+		expect(content).toContain("debug-msg");
+		expect(content).toContain("info-msg");
+		expect(content).toContain("warn-msg");
+		expect(content).toContain("error-msg");
+	});
+
+	it("should format log line with timestamp, level, module, message", async () => {
+		const { createLogger, configureLogDir, flushLogs } = await import("../logger");
+		configureLogDir(TEST_LOG_DIR);
+
+		const logger = createLogger("fmt");
+		logger.info("test-line");
+
+		await flushLogs();
+
+		const files = readdirSync(TEST_LOG_DIR);
+		const content = readFileSync(join(TEST_LOG_DIR, files[0]), "utf-8");
+		const line = content.trim();
+
+		expect(line).toMatch(/^\[\d{4}-\d{2}-\d{2}T/);
+		expect(line).toContain("[INFO]");
+		expect(line).toContain("[fmt]");
+		expect(line).toContain("test-line");
+	});
+
+	it("should include JSON data when provided", async () => {
+		const { createLogger, configureLogDir, flushLogs } = await import("../logger");
+		configureLogDir(TEST_LOG_DIR);
+
+		const logger = createLogger("data-test");
+		logger.info("with-data", { key: "value", count: 42 });
+
+		await flushLogs();
+
+		const files = readdirSync(TEST_LOG_DIR);
+		const content = readFileSync(join(TEST_LOG_DIR, files[0]), "utf-8");
+		expect(content).toContain('"key":"value"');
+		expect(content).toContain('"count":42');
+	});
+
+	it("should use console.error for error level", async () => {
+		const { createLogger, configureLogDir, flushLogs } = await import("../logger");
+		configureLogDir(TEST_LOG_DIR);
+
+		const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+		const logger = createLogger("console-test");
+		logger.error("err-msg");
+
+		expect(errorSpy).toHaveBeenCalled();
+		const callArg = errorSpy.mock.calls[0][0] as string;
+		expect(callArg).toContain("[ERROR]");
+		expect(callArg).toContain("err-msg");
+
+		await flushLogs();
+	});
+
+	it("should use console.warn for warn level", async () => {
+		const { createLogger, configureLogDir, flushLogs } = await import("../logger");
+		configureLogDir(TEST_LOG_DIR);
+
+		const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+		const logger = createLogger("console-warn");
+		logger.warn("warn-msg");
+
+		expect(warnSpy).toHaveBeenCalled();
+		const callArg = warnSpy.mock.calls[0][0] as string;
+		expect(callArg).toContain("[WARN]");
+
+		await flushLogs();
+	});
+
+	it("should clean up old log files based on maxAgeDays", async () => {
+		const { configureLogDir, flushLogs } = 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");
+
+		configureLogDir(TEST_LOG_DIR, { maxAgeDays: 5 });
+
+		await flushLogs();
+		await new Promise((r) => setTimeout(r, 200));
+
+		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");
+		configureLogDir(TEST_LOG_DIR);
+
+		const logger = createLogger("flush-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");
+	});
+
+	it("should create default log dir if not configured", async () => {
+		const { createLogger, flushLogs } = await import("../logger");
+		const logger = createLogger("default-dir");
+		logger.info("default test");
+
+		await flushLogs();
+
+		expect(existsSync("logs") || true).toBe(true);
+	});
+});

package/templates/shared/components/ErrorBoundary.tsx

@@ -0,0 +1,58 @@
+import React, { Component, type ErrorInfo, type ReactNode } from "react";
+
+interface Props {
+  children: ReactNode;
+  fallback?: ReactNode;
+}
+
+interface State {
+  hasError: boolean;
+  error: Error | null;
+}
+
+export class ErrorBoundary extends Component<Props, State> {
+  constructor(props: Props) {
+    super(props);
+    this.state = { hasError: false, error: null };
+  }
+
+  static getDerivedStateFromError(error: Error): State {
+    return { hasError: true, error };
+  }
+
+  componentDidCatch(error: Error, errorInfo: ErrorInfo): void {
+    console.error("[ErrorBoundary]", error, errorInfo);
+  }
+
+  handleRetry = (): void => {
+    this.setState({ hasError: false, error: null });
+  };
+
+  render(): ReactNode {
+    if (this.state.hasError) {
+      if (this.props.fallback) {
+        return this.props.fallback;
+      }
+
+      return (
+        <div className="flex flex-col items-center justify-center h-full p-8 bg-[var(--color-bg-primary)] text-[var(--color-text-primary)]">
+          <div className="text-4xl mb-4">⚠️</div>
+          <h2 className="text-lg font-semibold mb-2">Something went wrong</h2>
+          <p className="text-sm text-[var(--color-text-secondary)] mb-4 max-w-md text-center">
+            {this.state.error?.message || "An unexpected error occurred"}
+          </p>
+          <button
+            onClick={this.handleRetry}
+            className="px-4 py-2 bg-[var(--color-accent)] hover:bg-[var(--color-accent-hover)] text-white rounded-lg transition-colors text-sm"
+            role="button"
+            aria-label="Retry"
+          >
+            Retry
+          </button>
+        </div>
+      );
+    }
+
+    return this.props.children;
+  }
+}

package/templates/shared/env.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="vite/client" />
+
+interface ImportMetaEnv {
+	readonly DEV?: boolean;
+	readonly PROD?: boolean;
+	readonly MODE?: string;
+}
+
+interface ImportMeta {
+	readonly env: ImportMetaEnv;
+}

package/templates/shared/http-routes.ts

@@ -0,0 +1,230 @@
+/**
+ * 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 "./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" }));
+  }
+}