viteboard 0.1.0

package/vite.config.ts

@@ -0,0 +1,694 @@
+// @ts-nocheck — runs under esbuild/Node at dev time; not part of the `tsc` (src-only) build.
+import { defineConfig, type Plugin, type Connect } from "vite";
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import type { IncomingMessage, ServerResponse } from "node:http";
+
+const WORKSPACE_DIR = ".workspace";
+const WORKSPACE_FILE = "workspace.json";
+const IGNORE_DIRS = new Set([
+  ".git",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  ".next",
+  "out",
+]);
+
+const MIME: Record<string, string> = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".md": "text/markdown; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+};
+
+const execFileAsync = promisify(execFile);
+
+type WorkspaceManifest = {
+  version: 1;
+  projects: WorkspaceProjectRecord[];
+};
+
+type WorkspaceProjectRecord = {
+  id: string;
+  label: string;
+  rootPath: string;
+};
+
+type WorkspaceProject = WorkspaceProjectRecord & {
+  docsRoots: DocsRoot[];
+};
+
+type DocsRoot = {
+  id: string;
+  projectId: string;
+  projectLabel: string;
+  absPath: string;
+  relativePath: string;
+  displayPath: string;
+};
+
+type WorkspaceResponse = {
+  projects: Array<{
+    id: string;
+    label: string;
+    docsRoots: Array<{
+      id: string;
+      projectId: string;
+      projectLabel: string;
+      relativePath: string;
+      displayPath: string;
+    }>;
+  }>;
+};
+
+type TreeNode =
+  | { type: "file"; name: string; path: string }
+  | { type: "dir"; name: string; path: string; children: TreeNode[] };
+
+function contentApiPlugin(): Plugin {
+  const cwd = process.cwd();
+  const workspaceDir = path.resolve(cwd, WORKSPACE_DIR);
+  const workspaceFile = path.join(workspaceDir, WORKSPACE_FILE);
+
+  function send(res: ServerResponse, status: number, body: unknown): void {
+    res.statusCode = status;
+    res.setHeader("Content-Type", "application/json; charset=utf-8");
+    res.end(JSON.stringify(body));
+  }
+
+  function sendText(res: ServerResponse, status: number, body: string, type: string): void {
+    res.statusCode = status;
+    res.setHeader("Content-Type", type);
+    res.end(body);
+  }
+
+  function readBody(req: IncomingMessage): Promise<string> {
+    return new Promise((resolve, reject) => {
+      let data = "";
+      req.on("data", (chunk) => {
+        data += chunk;
+        if (data.length > 64 * 1024 * 1024) {
+          reject(new Error("Payload too large"));
+          req.destroy();
+        }
+      });
+      req.on("end", () => resolve(data));
+      req.on("error", reject);
+    });
+  }
+
+  function hashPath(value: string): string {
+    let hash = 2166136261;
+    for (let i = 0; i < value.length; i++) {
+      hash ^= value.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(36);
+  }
+
+  async function ensureWorkspaceDir(): Promise<void> {
+    await fs.mkdir(workspaceDir, { recursive: true });
+  }
+
+  async function loadManifest(): Promise<WorkspaceManifest> {
+    try {
+      const raw = await fs.readFile(workspaceFile, "utf-8");
+      const parsed = JSON.parse(raw) as Partial<WorkspaceManifest>;
+      const projects = Array.isArray(parsed.projects)
+        ? parsed.projects
+            .filter((item): item is WorkspaceProjectRecord => {
+              return !!item && typeof item.id === "string" && typeof item.rootPath === "string";
+            })
+            .map((item) => ({
+              id: item.id,
+              label: typeof item.label === "string" && item.label.trim() ? item.label.trim() : path.basename(item.rootPath),
+              rootPath: path.resolve(item.rootPath),
+            }))
+        : [];
+      return { version: 1, projects };
+    } catch {
+      return { version: 1, projects: [] };
+    }
+  }
+
+  async function saveManifest(manifest: WorkspaceManifest): Promise<void> {
+    await ensureWorkspaceDir();
+    await fs.writeFile(workspaceFile, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+  }
+
+  async function dirExists(absPath: string): Promise<boolean> {
+    try {
+      return (await fs.stat(absPath)).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+
+  async function loadProjects(): Promise<WorkspaceProjectRecord[]> {
+    const manifest = await loadManifest();
+    return manifest.projects.filter((item, index, list) => {
+      return list.findIndex((other) => other.rootPath === item.rootPath) === index;
+    });
+  }
+
+  async function openProjectPicker(): Promise<string | null> {
+    if (process.platform === "darwin") {
+      try {
+        const { stdout } = await execFileAsync("osascript", [
+          "-e",
+          'set chosenFolder to choose folder with prompt "Select a project root to add to ViteBoard"',
+          "-e",
+          'POSIX path of chosenFolder',
+        ]);
+        const picked = stdout.trim();
+        return picked || null;
+      } catch {
+        return null;
+      }
+    }
+
+    if (process.platform === "win32") {
+      const script = [
+        "Add-Type -AssemblyName System.Windows.Forms",
+        '$dialog = New-Object System.Windows.Forms.FolderBrowserDialog',
+        '$dialog.Description = "Select a project root to add to ViteBoard"',
+        '$dialog.ShowNewFolderButton = $false',
+        'if ($dialog.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) {',
+        '  [Console]::Out.Write($dialog.SelectedPath)',
+        '}',
+      ].join("; ");
+      try {
+        const { stdout } = await execFileAsync("powershell", [
+          "-NoProfile",
+          "-STA",
+          "-Command",
+          script,
+        ]);
+        const picked = stdout.trim();
+        return picked || null;
+      } catch {
+        return null;
+      }
+    }
+
+    const linuxPickers: Array<[string, string[]]> = [
+      ["zenity", ["--file-selection", "--directory", "--title=Select a project root to add to ViteBoard"]],
+      ["kdialog", ["--getexistingdirectory", ".", "Select a project root to add to ViteBoard"]],
+    ];
+    let sawInstalledPicker = false;
+    for (const [command, args] of linuxPickers) {
+      try {
+        await execFileAsync("which", [command]);
+        sawInstalledPicker = true;
+        const { stdout } = await execFileAsync(command, args);
+        const picked = stdout.trim();
+        if (picked) return picked;
+      } catch {
+        if (sawInstalledPicker) return null;
+      }
+    }
+    throw new Error("No supported folder picker found. Install zenity or kdialog.");
+  }
+
+  function isIgnoredDir(name: string): boolean {
+    return name.startsWith(".") || IGNORE_DIRS.has(name);
+  }
+
+  async function discoverDocsRoots(project: WorkspaceProjectRecord): Promise<DocsRoot[]> {
+    const roots: DocsRoot[] = [];
+    const projectRoot = path.resolve(project.rootPath);
+
+    async function walk(absDir: string): Promise<void> {
+      let entries: import("node:fs").Dirent[];
+      try {
+        entries = await fs.readdir(absDir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (isIgnoredDir(entry.name)) continue;
+        const child = path.join(absDir, entry.name);
+        if (entry.name === "docs") {
+          const relativePath = path.relative(projectRoot, child).replace(/\\/g, "/") || "docs";
+          roots.push({
+            id: `root-${hashPath(child)}`,
+            projectId: project.id,
+            projectLabel: project.label,
+            absPath: child,
+            relativePath,
+            displayPath: relativePath,
+          });
+        }
+        await walk(child);
+      }
+    }
+
+    if (await dirExists(projectRoot)) {
+      if (path.basename(projectRoot) === "docs") {
+        roots.push({
+          id: `root-${hashPath(projectRoot)}`,
+          projectId: project.id,
+          projectLabel: project.label,
+          absPath: projectRoot,
+          relativePath: "docs",
+          displayPath: "docs",
+        });
+      }
+      await walk(projectRoot);
+    }
+
+    roots.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+    return roots.filter((root, index, list) => list.findIndex((other) => other.absPath === root.absPath) === index);
+  }
+
+  async function getWorkspace(): Promise<WorkspaceProject[]> {
+    const projects = await loadProjects();
+    const out: WorkspaceProject[] = [];
+
+    for (const project of projects) {
+      if (!(await dirExists(project.rootPath))) continue;
+      out.push({
+        ...project,
+        docsRoots: await discoverDocsRoots(project),
+      });
+    }
+    return out;
+  }
+
+  function toWorkspaceResponse(projects: WorkspaceProject[]): WorkspaceResponse {
+    return {
+      projects: projects.map((project) => ({
+        id: project.id,
+        label: project.label,
+        docsRoots: project.docsRoots.map((root) => ({
+          id: root.id,
+          projectId: root.projectId,
+          projectLabel: root.projectLabel,
+          relativePath: root.relativePath,
+          displayPath: root.displayPath,
+        })),
+      })),
+    };
+  }
+
+  async function resolveRoot(rootId: string): Promise<{ root: DocsRoot; nestedRoots: Set<string> } | null> {
+    const projects = await getWorkspace();
+    for (const project of projects) {
+      const root = project.docsRoots.find((item) => item.id === rootId);
+      if (!root) continue;
+      const nestedRoots = new Set(
+        project.docsRoots
+          .filter((item) => item.id !== root.id && item.absPath.startsWith(root.absPath + path.sep))
+          .map((item) => item.absPath)
+      );
+      return { root, nestedRoots };
+    }
+    return null;
+  }
+
+  function safeResolve(root: string, rel: string): string | null {
+    const normalized = path.normalize(String(rel ?? "").replace(/^[/\\]+/, "")).replace(/\\/g, "/");
+    const abs = path.resolve(root, normalized);
+    if (abs !== root && !abs.startsWith(root + path.sep)) return null;
+    return abs;
+  }
+
+  async function walkDocsRoot(dir: string, base: string, nestedRoots: Set<string>): Promise<TreeNode[]> {
+    let entries: import("node:fs").Dirent[];
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    const nodes: TreeNode[] = [];
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) continue;
+      const absEntry = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (nestedRoots.has(absEntry)) continue;
+        const rel = base ? `${base}/${entry.name}` : entry.name;
+        nodes.push({
+          type: "dir",
+          name: entry.name,
+          path: rel,
+          children: await walkDocsRoot(absEntry, rel, nestedRoots),
+        });
+      } else {
+        nodes.push({
+          type: "file",
+          name: entry.name,
+          path: base ? `${base}/${entry.name}` : entry.name,
+        });
+      }
+    }
+    nodes.sort((a, b) => {
+      if (a.type !== b.type) return a.type === "dir" ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+    return nodes;
+  }
+
+  /** Walk full project directory tree — returns only directories (no files). */
+  async function walkProjectTree(dir: string, base: string): Promise<TreeNode[]> {
+    let entries: import("node:fs").Dirent[];
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    const nodes: TreeNode[] = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith(".")) continue;
+      if (isIgnoredDir(entry.name)) continue;
+      const rel = base ? `${base}/${entry.name}` : entry.name;
+      nodes.push({
+        type: "dir",
+        name: entry.name,
+        path: rel,
+        children: await walkProjectTree(path.join(dir, entry.name), rel),
+      });
+    }
+    nodes.sort((a, b) => a.name.localeCompare(b.name));
+    return nodes;
+  }
+
+  const handler: Connect.NextHandleFunction = (req, res, next) => {
+    const url = req.url ?? "";
+    if (!url.startsWith("/__api/")) return next();
+
+    void (async () => {
+      try {
+        const parsed = new URL(url, "http://localhost");
+        const route = parsed.pathname;
+        const method = (req.method ?? "GET").toUpperCase();
+
+        if (route === "/__api/workspace" && method === "GET") {
+          return send(res, 200, await toWorkspaceResponse(await getWorkspace()));
+        }
+
+        if (route === "/__api/workspace/project" && method === "POST") {
+          const { rootPath, label } = JSON.parse(await readBody(req));
+          const absRoot = path.resolve(String(rootPath ?? "").trim());
+          if (!absRoot || !(await dirExists(absRoot))) {
+            return send(res, 400, { error: "Project root not found" });
+          }
+          const manifest = await loadManifest();
+          const project: WorkspaceProjectRecord = {
+            id: `project-${hashPath(absRoot)}`,
+            label: String(label ?? "").trim() || path.basename(absRoot) || absRoot,
+            rootPath: absRoot,
+          };
+          const existingIndex = manifest.projects.findIndex((item) => item.rootPath === absRoot || item.id === project.id);
+          if (existingIndex === -1) manifest.projects.push(project);
+          else manifest.projects.splice(existingIndex, 1, project);
+          await saveManifest(manifest);
+          return send(res, 200, await toWorkspaceResponse(await getWorkspace()));
+        }
+
+        if (route === "/__api/workspace/pick-project" && method === "POST") {
+          const picked = await openProjectPicker();
+          if (!picked) return send(res, 200, { cancelled: true, workspace: await toWorkspaceResponse(await getWorkspace()) });
+          const absRoot = path.resolve(picked);
+          if (!(await dirExists(absRoot))) return send(res, 400, { error: "Project root not found" });
+          const manifest = await loadManifest();
+          const project: WorkspaceProjectRecord = {
+            id: `project-${hashPath(absRoot)}`,
+            label: path.basename(absRoot) || absRoot,
+            rootPath: absRoot,
+          };
+          const existingIndex = manifest.projects.findIndex((item) => item.rootPath === absRoot || item.id === project.id);
+          if (existingIndex === -1) manifest.projects.push(project);
+          else manifest.projects.splice(existingIndex, 1, project);
+          await saveManifest(manifest);
+          return send(res, 200, { cancelled: false, workspace: await toWorkspaceResponse(await getWorkspace()), addedProjectId: project.id });
+        }
+
+        if (route === "/__api/workspace/project/docs-root" && method === "POST") {
+          const { projectId } = JSON.parse(await readBody(req));
+          const manifest = await loadManifest();
+          const project = manifest.projects.find((item) => item.id === String(projectId ?? ""));
+          if (!project) return send(res, 404, { error: "Project not found" });
+          const docsPath = path.join(project.rootPath, "docs");
+          await fs.mkdir(docsPath, { recursive: true });
+          const workspace = await getWorkspace();
+          const refreshedProject = workspace.find((item) => item.id === project.id);
+          const root = refreshedProject?.docsRoots.find((item) => item.absPath === docsPath)
+            ?? refreshedProject?.docsRoots[0];
+          if (!root) return send(res, 500, { error: "Could not create docs root" });
+          return send(res, 200, {
+            root: {
+              id: root.id,
+              projectId: root.projectId,
+              projectLabel: root.projectLabel,
+              relativePath: root.relativePath,
+              displayPath: root.displayPath,
+            },
+            workspace: await toWorkspaceResponse(workspace),
+          });
+        }
+
+        if (route === "/__api/workspace/project/docs-area" && method === "POST") {
+          const { projectId, folderName } = JSON.parse(await readBody(req));
+          const manifest = await loadManifest();
+          const project = manifest.projects.find((item) => item.id === String(projectId ?? ""));
+          if (!project) return send(res, 404, { error: "Project not found" });
+          const folderPath = path.join(project.rootPath, String(folderName ?? ""));
+          const docsPath = path.join(folderPath, "docs");
+          await fs.mkdir(docsPath, { recursive: true });
+          const workspace = await getWorkspace();
+          const refreshedProject = workspace.find((item) => item.id === project.id);
+          const root = refreshedProject?.docsRoots.find((item) => item.absPath === docsPath);
+          if (!root) return send(res, 500, { error: "Could not create docs area" });
+          return send(res, 200, {
+            root: {
+              id: root.id,
+              projectId: root.projectId,
+              projectLabel: root.projectLabel,
+              relativePath: root.relativePath,
+              displayPath: root.displayPath,
+            },
+            workspace: await toWorkspaceResponse(workspace),
+          });
+        }
+
+        if (route === "/__api/workspace/project/create-docs-folder" && method === "POST") {
+          const { projectId, parentPath } = JSON.parse(await readBody(req));
+          const manifest = await loadManifest();
+          const project = manifest.projects.find((item) => item.id === String(projectId ?? ""));
+          if (!project) return send(res, 404, { error: "Project not found" });
+          const docsPath = path.join(project.rootPath, String(parentPath ?? ""), "docs");
+          await fs.mkdir(docsPath, { recursive: true });
+          return send(res, 200, { ok: true, workspace: await toWorkspaceResponse(await getWorkspace()) });
+        }
+
+        if (route === "/__api/workspace/project" && method === "DELETE") {
+          const id = parsed.searchParams.get("id") ?? "";
+          const manifest = await loadManifest();
+          manifest.projects = manifest.projects.filter((item) => item.id !== id);
+          await saveManifest(manifest);
+          return send(res, 200, await toWorkspaceResponse(await getWorkspace()));
+        }
+
+        if (route === "/__api/tree" && method === "GET") {
+          const rootId = parsed.searchParams.get("rootId") ?? "";
+          const resolved = await resolveRoot(rootId);
+          if (!resolved) return send(res, 404, { error: "Docs root not found" });
+          const tree = await walkDocsRoot(resolved.root.absPath, "", resolved.nestedRoots);
+          return send(res, 200, { tree });
+        }
+
+        if (route === "/__api/project-tree" && method === "GET") {
+          const projectId = parsed.searchParams.get("projectId") ?? "";
+          const workspace = await getWorkspace();
+          const project = workspace.find(p => p.id === projectId);
+          if (!project) return send(res, 404, { error: "Project not found" });
+          const tree = await walkProjectTree(project.rootPath, "");
+          return send(res, 200, { tree });
+        }
+
+        if (route === "/__api/file" && method === "GET") {
+          const rootId = parsed.searchParams.get("rootId") ?? "";
+          const rel = parsed.searchParams.get("path") ?? "";
+          const resolved = await resolveRoot(rootId);
+          if (!resolved) return send(res, 404, { error: "Docs root not found" });
+          const abs = safeResolve(resolved.root.absPath, rel);
+          if (!abs) return send(res, 400, { error: "Invalid path" });
+          try {
+            const content = await fs.readFile(abs, "utf-8");
+            return send(res, 200, { path: rel, content });
+          } catch {
+            return send(res, 404, { error: "Not found" });
+          }
+        }
+
+        if (route === "/__api/file" && method === "PUT") {
+          const { rootId, path: rel, content } = JSON.parse(await readBody(req));
+          const resolved = await resolveRoot(String(rootId ?? ""));
+          if (!resolved) return send(res, 404, { error: "Docs root not found" });
+          const abs = safeResolve(resolved.root.absPath, String(rel));
+          if (!abs) return send(res, 400, { error: "Invalid path" });
+          await fs.mkdir(path.dirname(abs), { recursive: true });
+          await fs.writeFile(abs, String(content ?? ""), "utf-8");
+          return send(res, 200, { ok: true, path: rel });
+        }
+
+        if (route === "/__api/directory" && method === "PUT") {
+          const { rootId, path: rel } = JSON.parse(await readBody(req));
+          const resolved = await resolveRoot(String(rootId ?? ""));
+          if (!resolved) return send(res, 404, { error: "Docs root not found" });
+          const abs = safeResolve(resolved.root.absPath, String(rel));
+          if (!abs) return send(res, 400, { error: "Invalid path" });
+          await fs.mkdir(abs, { recursive: true });
+          return send(res, 200, { ok: true, path: rel });
+        }
+
+        if (route === "/__api/file" && method === "DELETE") {
+          const rootId = parsed.searchParams.get("rootId") ?? "";
+          const rel = parsed.searchParams.get("path") ?? "";
+          const resolved = await resolveRoot(rootId);
+          if (!resolved) return send(res, 404, { error: "Docs root not found" });
+          const abs = safeResolve(resolved.root.absPath, rel);
+          if (!abs) return send(res, 400, { error: "Invalid path" });
+          try {
+            await fs.unlink(abs);
+          } catch (err) {
+            if ((err as NodeJS.ErrnoException).code !== "ENOENT") throw err;
+          }
+          return send(res, 200, { ok: true });
+        }
+
+        if (route === "/__api/file" && method === "PATCH") {
+          // Rename/move: { rootId, oldPath, newPath }
+          const { rootId, oldPath, newPath, ignoreMissing } = JSON.parse(await readBody(req));
+          const resolved = await resolveRoot(String(rootId ?? ""));
+          if (!resolved) return send(res, 404, { error: "Docs root not found" });
+          const absOld = safeResolve(resolved.root.absPath, String(oldPath));
+          const absNew = safeResolve(resolved.root.absPath, String(newPath));
+          if (!absOld || !absNew) return send(res, 400, { error: "Invalid path" });
+          await fs.mkdir(path.dirname(absNew), { recursive: true });
+          try {
+            await fs.rename(absOld, absNew);
+          } catch (err) {
+            if (ignoreMissing && (err as NodeJS.ErrnoException).code === "ENOENT") {
+              return send(res, 200, { ok: true, path: newPath, skipped: true });
+            }
+            throw err;
+          }
+          return send(res, 200, { ok: true, path: newPath });
+        }
+
+        if (route === "/__api/board" && method === "GET") {
+          const rootId = parsed.searchParams.get("rootId") ?? "";
+          const id = parsed.searchParams.get("id") ?? "";
+          const resolved = await resolveRoot(rootId);
+          if (!resolved) return send(res, 404, { error: "Docs root not found" });
+          const abs = safeResolve(resolved.root.absPath, `${id}.board.json`);
+          if (!abs) return send(res, 400, { error: "Invalid id" });
+          try {
+            const content = await fs.readFile(abs, "utf-8");
+            return send(res, 200, { id, doc: JSON.parse(content) });
+          } catch {
+            return send(res, 404, { error: "Not found" });
+          }
+        }
+
+        if (route === "/__api/board" && method === "PUT") {
+          const { rootId, id, doc } = JSON.parse(await readBody(req));
+          const resolved = await resolveRoot(String(rootId ?? ""));
+          if (!resolved) return send(res, 404, { error: "Docs root not found" });
+          const abs = safeResolve(resolved.root.absPath, `${String(id)}.board.json`);
+          if (!abs) return send(res, 400, { error: "Invalid id" });
+          await fs.mkdir(path.dirname(abs), { recursive: true });
+          await fs.writeFile(abs, JSON.stringify(doc, null, 2) + "\n", "utf-8");
+          return send(res, 200, { ok: true, id });
+        }
+
+        if (route === "/__api/board" && method === "DELETE") {
+          const rootId = parsed.searchParams.get("rootId") ?? "";
+          const id = parsed.searchParams.get("id") ?? "";
+          const resolved = await resolveRoot(rootId);
+          if (!resolved) return send(res, 404, { error: "Docs root not found" });
+          const abs = safeResolve(resolved.root.absPath, `${id}.board.json`);
+          if (!abs) return send(res, 400, { error: "Invalid id" });
+          try {
+            await fs.unlink(abs);
+          } catch (err) {
+            if ((err as NodeJS.ErrnoException).code !== "ENOENT") throw err;
+          }
+          return send(res, 200, { ok: true, id });
+        }
+
+        if (route === "/__api/asset" && method === "GET") {
+          const rootId = parsed.searchParams.get("rootId") ?? "";
+          const rel = parsed.searchParams.get("path") ?? "";
+          const resolved = await resolveRoot(rootId);
+          if (!resolved) return send(res, 404, { error: "Docs root not found" });
+          const abs = safeResolve(resolved.root.absPath, rel);
+          if (!abs) return send(res, 400, { error: "Invalid path" });
+          try {
+            const buf = await fs.readFile(abs);
+            res.statusCode = 200;
+            res.setHeader("Content-Type", MIME[path.extname(abs).toLowerCase()] ?? "application/octet-stream");
+            res.setHeader("Cache-Control", "no-cache");
+            return res.end(buf);
+          } catch {
+            return send(res, 404, { error: "Not found" });
+          }
+        }
+
+        if (route === "/__api/asset" && method === "POST") {
+          const { rootId, name, base64 } = JSON.parse(await readBody(req));
+          const resolved = await resolveRoot(String(rootId ?? ""));
+          if (!resolved) return send(res, 404, { error: "Docs root not found" });
+          const ext = (path.extname(String(name ?? "")) || ".png").toLowerCase();
+          const safeBase = String(name ?? "image")
+            .replace(/\.[^.]*$/, "")
+            .replace(/[^a-z0-9-_]/gi, "-")
+            .slice(0, 40);
+          const unique = `${safeBase || "image"}-${Date.now().toString(36)}${ext}`;
+          const rel = `assets/${unique}`;
+          const abs = safeResolve(resolved.root.absPath, rel);
+          if (!abs) return send(res, 400, { error: "Invalid path" });
+          await fs.mkdir(path.dirname(abs), { recursive: true });
+          await fs.writeFile(abs, Buffer.from(String(base64), "base64"));
+          return send(res, 200, { ok: true, path: rel });
+        }
+
+        if (route === "/__api/workspace-file" && method === "GET") {
+          await ensureWorkspaceDir();
+          const manifest = await loadManifest();
+          return sendText(res, 200, JSON.stringify(manifest, null, 2) + "\n", "application/json; charset=utf-8");
+        }
+
+        return send(res, 404, { error: "Unknown endpoint" });
+      } catch (err) {
+        return send(res, 500, { error: (err as Error).message });
+      }
+    })();
+  };
+
+  return {
+    name: "viteboard-content-api",
+    configureServer(server) {
+      server.middlewares.use(handler);
+    },
+    configurePreviewServer(server) {
+      server.middlewares.use(handler);
+    },
+  };
+}
+
+export default defineConfig({
+  plugins: [contentApiPlugin()],
+});