@dyyz1993/create-agent 2.0.1 → 2.1.1

package/templates/shared/components/ErrorBoundary.tsx

@@ -1,58 +1,59 @@
-import React, { Component, type ErrorInfo, type ReactNode } from "react";
+import { Component, type ErrorInfo, type ReactNode } from "react";
 
 interface Props {
-  children: ReactNode;
-  fallback?: ReactNode;
+	children: ReactNode;
+	fallback?: ReactNode;
 }
 
 interface State {
-  hasError: boolean;
-  error: Error | null;
+	hasError: boolean;
+	error: Error | null;
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 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;
-  }
+	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/http-routes.ts

@@ -13,218 +13,238 @@ 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 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",
+	".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 + "/"));
+	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;
+	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;
+	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();
-  };
+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" }));
-  }
+	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 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,
+	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" }));
-  }
+	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" }));
+	}
 }