refactoring the api endpoints to be separate files to reduce context usage

apps/server/src/routes/fs/common.ts

@@ -0,0 +1,21 @@
+/**
+ * Common utilities for fs routes
+ */
+
+import { createLogger } from "../../lib/logger.js";
+
+const logger = createLogger("FS");
+
+/**
+ * Get error message from error object
+ */
+export function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : "Unknown error";
+}
+
+/**
+ * Log error details consistently
+ */
+export function logError(error: unknown, context: string): void {
+  logger.error(`❌ ${context}:`, error);
+}

apps/server/src/routes/fs/index.ts

@@ -0,0 +1,42 @@
+/**
+ * File system routes
+ * Provides REST API equivalents for Electron IPC file operations
+ */
+
+import { Router } from "express";
+import type { EventEmitter } from "../../lib/events.js";
+import { createReadHandler } from "./routes/read.js";
+import { createWriteHandler } from "./routes/write.js";
+import { createMkdirHandler } from "./routes/mkdir.js";
+import { createReaddirHandler } from "./routes/readdir.js";
+import { createExistsHandler } from "./routes/exists.js";
+import { createStatHandler } from "./routes/stat.js";
+import { createDeleteHandler } from "./routes/delete.js";
+import { createValidatePathHandler } from "./routes/validate-path.js";
+import { createResolveDirectoryHandler } from "./routes/resolve-directory.js";
+import { createSaveImageHandler } from "./routes/save-image.js";
+import { createBrowseHandler } from "./routes/browse.js";
+import { createImageHandler } from "./routes/image.js";
+import { createSaveBoardBackgroundHandler } from "./routes/save-board-background.js";
+import { createDeleteBoardBackgroundHandler } from "./routes/delete-board-background.js";
+
+export function createFsRoutes(_events: EventEmitter): Router {
+  const router = Router();
+
+  router.post("/read", createReadHandler());
+  router.post("/write", createWriteHandler());
+  router.post("/mkdir", createMkdirHandler());
+  router.post("/readdir", createReaddirHandler());
+  router.post("/exists", createExistsHandler());
+  router.post("/stat", createStatHandler());
+  router.post("/delete", createDeleteHandler());
+  router.post("/validate-path", createValidatePathHandler());
+  router.post("/resolve-directory", createResolveDirectoryHandler());
+  router.post("/save-image", createSaveImageHandler());
+  router.post("/browse", createBrowseHandler());
+  router.get("/image", createImageHandler());
+  router.post("/save-board-background", createSaveBoardBackgroundHandler());
+  router.post("/delete-board-background", createDeleteBoardBackgroundHandler());
+
+  return router;
+}

apps/server/src/routes/fs/routes/browse.ts

@@ -0,0 +1,107 @@
+/**
+ * POST /browse endpoint - Browse directories for file browser UI
+ */
+
+import type { Request, Response } from "express";
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createBrowseHandler() {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { dirPath } = req.body as { dirPath?: string };
+
+      // Default to home directory if no path provided
+      const targetPath = dirPath ? path.resolve(dirPath) : os.homedir();
+
+      // Detect available drives on Windows
+      const detectDrives = async (): Promise<string[]> => {
+        if (os.platform() !== "win32") {
+          return [];
+        }
+
+        const drives: string[] = [];
+        const letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+        for (const letter of letters) {
+          const drivePath = `${letter}:\\`;
+          try {
+            await fs.access(drivePath);
+            drives.push(drivePath);
+          } catch {
+            // Drive doesn't exist, skip it
+          }
+        }
+
+        return drives;
+      };
+
+      // Get parent directory
+      const parentPath = path.dirname(targetPath);
+      const hasParent = parentPath !== targetPath;
+
+      // Get available drives
+      const drives = await detectDrives();
+
+      try {
+        const stats = await fs.stat(targetPath);
+
+        if (!stats.isDirectory()) {
+          res
+            .status(400)
+            .json({ success: false, error: "Path is not a directory" });
+          return;
+        }
+
+        // Read directory contents
+        const entries = await fs.readdir(targetPath, { withFileTypes: true });
+
+        // Filter for directories only and add parent directory option
+        const directories = entries
+          .filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
+          .map((entry) => ({
+            name: entry.name,
+            path: path.join(targetPath, entry.name),
+          }))
+          .sort((a, b) => a.name.localeCompare(b.name));
+
+        res.json({
+          success: true,
+          currentPath: targetPath,
+          parentPath: hasParent ? parentPath : null,
+          directories,
+          drives,
+        });
+      } catch (error) {
+        // Handle permission errors gracefully - still return path info so user can navigate away
+        const errorMessage =
+          error instanceof Error ? error.message : "Failed to read directory";
+        const isPermissionError =
+          errorMessage.includes("EPERM") || errorMessage.includes("EACCES");
+
+        if (isPermissionError) {
+          // Return success with empty directories so user can still navigate to parent
+          res.json({
+            success: true,
+            currentPath: targetPath,
+            parentPath: hasParent ? parentPath : null,
+            directories: [],
+            drives,
+            warning:
+              "Permission denied - grant Full Disk Access to Terminal in System Preferences > Privacy & Security",
+          });
+        } else {
+          res.status(400).json({
+            success: false,
+            error: errorMessage,
+          });
+        }
+      }
+    } catch (error) {
+      logError(error, "Browse directories failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/fs/routes/delete-board-background.ts

@@ -0,0 +1,43 @@
+/**
+ * POST /delete-board-background endpoint - Delete board background image
+ */
+
+import type { Request, Response } from "express";
+import fs from "fs/promises";
+import path from "path";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createDeleteBoardBackgroundHandler() {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { projectPath } = req.body as { projectPath: string };
+
+      if (!projectPath) {
+        res.status(400).json({
+          success: false,
+          error: "projectPath is required",
+        });
+        return;
+      }
+
+      const boardDir = path.join(projectPath, ".automaker", "board");
+
+      try {
+        // Try to remove all files in the board directory
+        const files = await fs.readdir(boardDir);
+        for (const file of files) {
+          if (file.startsWith("background")) {
+            await fs.unlink(path.join(boardDir, file));
+          }
+        }
+      } catch {
+        // Directory may not exist, that's fine
+      }
+
+      res.json({ success: true });
+    } catch (error) {
+      logError(error, "Delete board background failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/fs/routes/delete.ts

@@ -0,0 +1,29 @@
+/**
+ * POST /delete endpoint - Delete file
+ */
+
+import type { Request, Response } from "express";
+import fs from "fs/promises";
+import { validatePath } from "../../../lib/security.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createDeleteHandler() {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { filePath } = req.body as { filePath: string };
+
+      if (!filePath) {
+        res.status(400).json({ success: false, error: "filePath is required" });
+        return;
+      }
+
+      const resolvedPath = validatePath(filePath);
+      await fs.rm(resolvedPath, { recursive: true });
+
+      res.json({ success: true });
+    } catch (error) {
+      logError(error, "Delete file failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/fs/routes/exists.ts

@@ -0,0 +1,35 @@
+/**
+ * POST /exists endpoint - Check if file/directory exists
+ */
+
+import type { Request, Response } from "express";
+import fs from "fs/promises";
+import path from "path";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createExistsHandler() {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { filePath } = req.body as { filePath: string };
+
+      if (!filePath) {
+        res.status(400).json({ success: false, error: "filePath is required" });
+        return;
+      }
+
+      // For exists, we check but don't require the path to be pre-allowed
+      // This allows the UI to validate user-entered paths
+      const resolvedPath = path.resolve(filePath);
+
+      try {
+        await fs.access(resolvedPath);
+        res.json({ success: true, exists: true });
+      } catch {
+        res.json({ success: true, exists: false });
+      }
+    } catch (error) {
+      logError(error, "Check exists failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/fs/routes/image.ts

@@ -0,0 +1,64 @@
+/**
+ * GET /image endpoint - Serve image files
+ */
+
+import type { Request, Response } from "express";
+import fs from "fs/promises";
+import path from "path";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createImageHandler() {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { path: imagePath, projectPath } = req.query as {
+        path?: string;
+        projectPath?: string;
+      };
+
+      if (!imagePath) {
+        res.status(400).json({ success: false, error: "path is required" });
+        return;
+      }
+
+      // Resolve full path
+      const fullPath = path.isAbsolute(imagePath)
+        ? imagePath
+        : projectPath
+        ? path.join(projectPath, imagePath)
+        : imagePath;
+
+      // Check if file exists
+      try {
+        await fs.access(fullPath);
+      } catch {
+        res.status(404).json({ success: false, error: "Image not found" });
+        return;
+      }
+
+      // Read the file
+      const buffer = await fs.readFile(fullPath);
+
+      // Determine MIME type from extension
+      const ext = path.extname(fullPath).toLowerCase();
+      const mimeTypes: Record<string, string> = {
+        ".png": "image/png",
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".gif": "image/gif",
+        ".webp": "image/webp",
+        ".svg": "image/svg+xml",
+        ".bmp": "image/bmp",
+      };
+
+      res.setHeader(
+        "Content-Type",
+        mimeTypes[ext] || "application/octet-stream"
+      );
+      res.setHeader("Cache-Control", "public, max-age=3600");
+      res.send(buffer);
+    } catch (error) {
+      logError(error, "Serve image failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/fs/routes/mkdir.ts

@@ -0,0 +1,34 @@
+/**
+ * POST /mkdir endpoint - Create directory
+ */
+
+import type { Request, Response } from "express";
+import fs from "fs/promises";
+import path from "path";
+import { addAllowedPath } from "../../../lib/security.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createMkdirHandler() {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { dirPath } = req.body as { dirPath: string };
+
+      if (!dirPath) {
+        res.status(400).json({ success: false, error: "dirPath is required" });
+        return;
+      }
+
+      const resolvedPath = path.resolve(dirPath);
+
+      await fs.mkdir(resolvedPath, { recursive: true });
+
+      // Add the new directory to allowed paths for tracking
+      addAllowedPath(resolvedPath);
+
+      res.json({ success: true });
+    } catch (error) {
+      logError(error, "Create directory failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/fs/routes/read.ts

@@ -0,0 +1,29 @@
+/**
+ * POST /read endpoint - Read file
+ */
+
+import type { Request, Response } from "express";
+import fs from "fs/promises";
+import { validatePath } from "../../../lib/security.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createReadHandler() {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { filePath } = req.body as { filePath: string };
+
+      if (!filePath) {
+        res.status(400).json({ success: false, error: "filePath is required" });
+        return;
+      }
+
+      const resolvedPath = validatePath(filePath);
+      const content = await fs.readFile(resolvedPath, "utf-8");
+
+      res.json({ success: true, content });
+    } catch (error) {
+      logError(error, "Read file failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/fs/routes/readdir.ts

@@ -0,0 +1,35 @@
+/**
+ * POST /readdir endpoint - Read directory
+ */
+
+import type { Request, Response } from "express";
+import fs from "fs/promises";
+import { validatePath } from "../../../lib/security.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createReaddirHandler() {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { dirPath } = req.body as { dirPath: string };
+
+      if (!dirPath) {
+        res.status(400).json({ success: false, error: "dirPath is required" });
+        return;
+      }
+
+      const resolvedPath = validatePath(dirPath);
+      const entries = await fs.readdir(resolvedPath, { withFileTypes: true });
+
+      const result = entries.map((entry) => ({
+        name: entry.name,
+        isDirectory: entry.isDirectory(),
+        isFile: entry.isFile(),
+      }));
+
+      res.json({ success: true, entries: result });
+    } catch (error) {
+      logError(error, "Read directory failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/fs/routes/resolve-directory.ts

@@ -0,0 +1,126 @@
+/**
+ * POST /resolve-directory endpoint - Resolve directory path from directory name
+ */
+
+import type { Request, Response } from "express";
+import fs from "fs/promises";
+import path from "path";
+import { addAllowedPath } from "../../../lib/security.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createResolveDirectoryHandler() {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { directoryName, sampleFiles, fileCount } = req.body as {
+        directoryName: string;
+        sampleFiles?: string[];
+        fileCount?: number;
+      };
+
+      if (!directoryName) {
+        res
+          .status(400)
+          .json({ success: false, error: "directoryName is required" });
+        return;
+      }
+
+      // If directoryName looks like an absolute path, try validating it directly
+      if (path.isAbsolute(directoryName) || directoryName.includes(path.sep)) {
+        try {
+          const resolvedPath = path.resolve(directoryName);
+          const stats = await fs.stat(resolvedPath);
+          if (stats.isDirectory()) {
+            addAllowedPath(resolvedPath);
+            return res.json({
+              success: true,
+              path: resolvedPath,
+            });
+          }
+        } catch {
+          // Not a valid absolute path, continue to search
+        }
+      }
+
+      // Search for directory in common locations
+      const searchPaths: string[] = [
+        process.cwd(), // Current working directory
+        process.env.HOME || process.env.USERPROFILE || "", // User home
+        path.join(
+          process.env.HOME || process.env.USERPROFILE || "",
+          "Documents"
+        ),
+        path.join(process.env.HOME || process.env.USERPROFILE || "", "Desktop"),
+        // Common project locations
+        path.join(
+          process.env.HOME || process.env.USERPROFILE || "",
+          "Projects"
+        ),
+      ].filter(Boolean);
+
+      // Also check parent of current working directory
+      try {
+        const parentDir = path.dirname(process.cwd());
+        if (!searchPaths.includes(parentDir)) {
+          searchPaths.push(parentDir);
+        }
+      } catch {
+        // Ignore
+      }
+
+      // Search for directory matching the name and file structure
+      for (const searchPath of searchPaths) {
+        try {
+          const candidatePath = path.join(searchPath, directoryName);
+          const stats = await fs.stat(candidatePath);
+
+          if (stats.isDirectory()) {
+            // Verify it matches by checking for sample files
+            if (sampleFiles && sampleFiles.length > 0) {
+              let matches = 0;
+              for (const sampleFile of sampleFiles.slice(0, 5)) {
+                // Remove directory name prefix from sample file path
+                const relativeFile = sampleFile.startsWith(directoryName + "/")
+                  ? sampleFile.substring(directoryName.length + 1)
+                  : sampleFile.split("/").slice(1).join("/") ||
+                    sampleFile.split("/").pop() ||
+                    sampleFile;
+
+                try {
+                  const filePath = path.join(candidatePath, relativeFile);
+                  await fs.access(filePath);
+                  matches++;
+                } catch {
+                  // File doesn't exist, continue checking
+                }
+              }
+
+              // If at least one file matches, consider it a match
+              if (matches === 0 && sampleFiles.length > 0) {
+                continue; // Try next candidate
+              }
+            }
+
+            // Found matching directory
+            addAllowedPath(candidatePath);
+            return res.json({
+              success: true,
+              path: candidatePath,
+            });
+          }
+        } catch {
+          // Directory doesn't exist at this location, continue searching
+          continue;
+        }
+      }
+
+      // Directory not found
+      res.status(404).json({
+        success: false,
+        error: `Directory "${directoryName}" not found in common locations. Please ensure the directory exists.`,
+      });
+    } catch (error) {
+      logError(error, "Resolve directory failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/fs/routes/save-board-background.ts

@@ -0,0 +1,56 @@
+/**
+ * POST /save-board-background endpoint - Save board background image
+ */
+
+import type { Request, Response } from "express";
+import fs from "fs/promises";
+import path from "path";
+import { addAllowedPath } from "../../../lib/security.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createSaveBoardBackgroundHandler() {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { data, filename, mimeType, projectPath } = req.body as {
+        data: string;
+        filename: string;
+        mimeType: string;
+        projectPath: string;
+      };
+
+      if (!data || !filename || !projectPath) {
+        res.status(400).json({
+          success: false,
+          error: "data, filename, and projectPath are required",
+        });
+        return;
+      }
+
+      // Create .automaker/board directory if it doesn't exist
+      const boardDir = path.join(projectPath, ".automaker", "board");
+      await fs.mkdir(boardDir, { recursive: true });
+
+      // Decode base64 data (remove data URL prefix if present)
+      const base64Data = data.replace(/^data:image\/\w+;base64,/, "");
+      const buffer = Buffer.from(base64Data, "base64");
+
+      // Use a fixed filename for the board background (overwrite previous)
+      const ext = path.extname(filename) || ".png";
+      const uniqueFilename = `background${ext}`;
+      const filePath = path.join(boardDir, uniqueFilename);
+
+      // Write file
+      await fs.writeFile(filePath, buffer);
+
+      // Add project path to allowed paths if not already
+      addAllowedPath(projectPath);
+
+      // Return the relative path for storage
+      const relativePath = `.automaker/board/${uniqueFilename}`;
+      res.json({ success: true, path: relativePath });
+    } catch (error) {
+      logError(error, "Save board background failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/fs/routes/save-image.ts

@@ -0,0 +1,56 @@
+/**
+ * POST /save-image endpoint - Save image to .automaker/images directory
+ */
+
+import type { Request, Response } from "express";
+import fs from "fs/promises";
+import path from "path";
+import { addAllowedPath } from "../../../lib/security.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createSaveImageHandler() {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { data, filename, mimeType, projectPath } = req.body as {
+        data: string;
+        filename: string;
+        mimeType: string;
+        projectPath: string;
+      };
+
+      if (!data || !filename || !projectPath) {
+        res.status(400).json({
+          success: false,
+          error: "data, filename, and projectPath are required",
+        });
+        return;
+      }
+
+      // Create .automaker/images directory if it doesn't exist
+      const imagesDir = path.join(projectPath, ".automaker", "images");
+      await fs.mkdir(imagesDir, { recursive: true });
+
+      // Decode base64 data (remove data URL prefix if present)
+      const base64Data = data.replace(/^data:image\/\w+;base64,/, "");
+      const buffer = Buffer.from(base64Data, "base64");
+
+      // Generate unique filename with timestamp
+      const timestamp = Date.now();
+      const ext = path.extname(filename) || ".png";
+      const baseName = path.basename(filename, ext);
+      const uniqueFilename = `${baseName}-${timestamp}${ext}`;
+      const filePath = path.join(imagesDir, uniqueFilename);
+
+      // Write file
+      await fs.writeFile(filePath, buffer);
+
+      // Add project path to allowed paths if not already
+      addAllowedPath(projectPath);
+
+      res.json({ success: true, path: filePath });
+    } catch (error) {
+      logError(error, "Save image failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/fs/routes/stat.ts

@@ -0,0 +1,37 @@
+/**
+ * POST /stat endpoint - Get file stats
+ */
+
+import type { Request, Response } from "express";
+import fs from "fs/promises";
+import { validatePath } from "../../../lib/security.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createStatHandler() {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { filePath } = req.body as { filePath: string };
+
+      if (!filePath) {
+        res.status(400).json({ success: false, error: "filePath is required" });
+        return;
+      }
+
+      const resolvedPath = validatePath(filePath);
+      const stats = await fs.stat(resolvedPath);
+
+      res.json({
+        success: true,
+        stats: {
+          isDirectory: stats.isDirectory(),
+          isFile: stats.isFile(),
+          size: stats.size,
+          mtime: stats.mtime,
+        },
+      });
+    } catch (error) {
+      logError(error, "Get file stats failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/fs/routes/validate-path.ts

@@ -0,0 +1,50 @@
+/**
+ * POST /validate-path endpoint - Validate and add path to allowed list
+ */
+
+import type { Request, Response } from "express";
+import fs from "fs/promises";
+import path from "path";
+import { addAllowedPath, isPathAllowed } from "../../../lib/security.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createValidatePathHandler() {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { filePath } = req.body as { filePath: string };
+
+      if (!filePath) {
+        res.status(400).json({ success: false, error: "filePath is required" });
+        return;
+      }
+
+      const resolvedPath = path.resolve(filePath);
+
+      // Check if path exists
+      try {
+        const stats = await fs.stat(resolvedPath);
+
+        if (!stats.isDirectory()) {
+          res
+            .status(400)
+            .json({ success: false, error: "Path is not a directory" });
+          return;
+        }
+
+        // Add to allowed paths
+        addAllowedPath(resolvedPath);
+
+        res.json({
+          success: true,
+          path: resolvedPath,
+          isAllowed: isPathAllowed(resolvedPath),
+        });
+      } catch {
+        res.status(400).json({ success: false, error: "Path does not exist" });
+      }
+    } catch (error) {
+      logError(error, "Validate path failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/fs/routes/write.ts

@@ -0,0 +1,36 @@
+/**
+ * POST /write endpoint - Write file
+ */
+
+import type { Request, Response } from "express";
+import fs from "fs/promises";
+import path from "path";
+import { validatePath } from "../../../lib/security.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createWriteHandler() {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { filePath, content } = req.body as {
+        filePath: string;
+        content: string;
+      };
+
+      if (!filePath) {
+        res.status(400).json({ success: false, error: "filePath is required" });
+        return;
+      }
+
+      const resolvedPath = validatePath(filePath);
+
+      // Ensure parent directory exists
+      await fs.mkdir(path.dirname(resolvedPath), { recursive: true });
+      await fs.writeFile(resolvedPath, content, "utf-8");
+
+      res.json({ success: true });
+    } catch (error) {
+      logError(error, "Write file failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}