wiki-viewer 1.0.0

package/.next/standalone/src/app/api/upload/[...path]/route.ts

@@ -0,0 +1,80 @@
+import { mkdir, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { NextResponse } from "next/server";
+import { getRootDir } from "@/lib/root-dir";
+
+const MAX_UPLOAD_BYTES = 50 * 1024 * 1024;
+
+function sanitizeFilename(name: string): string {
+	const lowered = name.toLowerCase();
+	const cleaned = lowered.replace(/[^a-z0-9._-]+/g, "-").replace(/-+/g, "-");
+	const trimmed = cleaned.replace(/^[-.]+/, "").replace(/-+$/, "");
+	return trimmed || "file";
+}
+
+async function pickAvailableName(dir: string, filename: string): Promise<string> {
+	const ext = path.extname(filename);
+	const stem = filename.slice(0, filename.length - ext.length);
+	let candidate = filename;
+	let n = 2;
+	while (true) {
+		try {
+			await stat(path.join(dir, candidate));
+			candidate = `${stem}-${n}${ext}`;
+			n += 1;
+		} catch {
+			return candidate;
+		}
+	}
+}
+
+export async function POST(
+	request: Request,
+	{ params }: { params: Promise<{ path: string[] }> },
+) {
+	const { path: segments } = await params;
+	const subPath = (segments ?? []).join("/");
+
+	// Save images in _uploads/ within getRootDir(), mirroring the page path
+	const uploadsDir = path.join(getRootDir(), "_uploads", subPath);
+	const resolved = path.resolve(uploadsDir);
+	if (!resolved.startsWith(getRootDir() + path.sep) && resolved !== getRootDir())
+		return NextResponse.json({ error: "Invalid path" }, { status: 400 });
+
+	let form: FormData;
+	try {
+		form = await request.formData();
+	} catch {
+		return NextResponse.json({ error: "Expected multipart/form-data" }, { status: 400 });
+	}
+
+	const file = form.get("file");
+	if (!(file instanceof File))
+		return NextResponse.json({ error: "Missing file field" }, { status: 400 });
+	if (file.size > MAX_UPLOAD_BYTES)
+		return NextResponse.json({ error: "File exceeds 50MB limit" }, { status: 413 });
+
+	const filename = sanitizeFilename(file.name || "file");
+
+	try {
+		await mkdir(uploadsDir, { recursive: true });
+		const finalName = await pickAvailableName(uploadsDir, filename);
+		const targetPath = path.join(uploadsDir, finalName);
+		const bytes = Buffer.from(await file.arrayBuffer());
+		await writeFile(targetPath, bytes);
+
+		const relParts = ["_uploads", subPath, finalName].filter(Boolean);
+		const relUrl = relParts.map(encodeURIComponent).join("/");
+		const relPath = relParts.join("/");
+		return NextResponse.json({
+			url: `/api/assets/${relUrl}`,
+			path: relPath,
+			absolutePath: targetPath,
+			size: bytes.length,
+			mimeType: file.type || "application/octet-stream",
+		});
+	} catch (err) {
+		const message = err instanceof Error ? err.message : "Write failed";
+		return NextResponse.json({ error: message }, { status: 500 });
+	}
+}

package/.next/standalone/src/app/api/wiki/app/route.ts

@@ -0,0 +1,41 @@
+import path from "node:path";
+import { NextResponse } from "next/server";
+import { getStatus, startApp, stopApp } from "@/lib/app-runner";
+import { getRootDir, safeRootPath } from "@/lib/root-dir";
+
+// GET /api/wiki/app?path=relative/path
+export async function GET(request: Request) {
+	const { searchParams } = new URL(request.url);
+	const rel = searchParams.get("path") ?? "";
+	return NextResponse.json(getStatus(rel));
+}
+
+// POST /api/wiki/app  { path: "relative/path" }
+export async function POST(request: Request) {
+	const body: { path?: string } = await request.json();
+	const rel = body.path;
+	if (!rel || typeof rel !== "string")
+		return NextResponse.json({ error: "Missing path" }, { status: 400 });
+
+	const abs = safeRootPath(rel);
+	if (!abs)
+		return NextResponse.json({ error: "Invalid path" }, { status: 400 });
+
+	try {
+		const result = await startApp(rel, abs);
+		return NextResponse.json(result);
+	} catch (e) {
+		return NextResponse.json({ error: String(e) }, { status: 500 });
+	}
+}
+
+// DELETE /api/wiki/app  { path: "relative/path" }
+export async function DELETE(request: Request) {
+	const body: { path?: string } = await request.json();
+	const rel = body.path;
+	if (!rel || typeof rel !== "string")
+		return NextResponse.json({ error: "Missing path" }, { status: 400 });
+
+	stopApp(rel);
+	return NextResponse.json({ ok: true });
+}

package/.next/standalone/src/app/api/wiki/content/route.ts

@@ -0,0 +1,60 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { NextResponse } from "next/server";
+import { safeRootPath } from "@/lib/root-dir";
+
+const TEXT_EXTS = new Set([
+	"txt", "md", "markdown", "json", "yaml", "yml", "toml", "csv",
+	"xml", "html", "css", "js", "ts", "tsx", "jsx", "sh", "bash",
+	"zsh", "rb", "py", "go", "rs", "java", "c", "cpp", "h", "php",
+	"swift", "kt", "lua", "sql", "scss",
+]);
+const MAX_EDIT_SIZE = 1 * 1024 * 1024; // 1MB
+
+function isTextFile(filename: string): boolean {
+	const ext = filename.split(".").pop()?.toLowerCase() ?? "";
+	return TEXT_EXTS.has(ext);
+}
+
+export async function GET(request: Request) {
+	const { searchParams } = new URL(request.url);
+	const rel = searchParams.get("path") ?? "";
+	const filePath = safeRootPath(rel);
+	if (!filePath)
+		return NextResponse.json({ error: "Invalid path" }, { status: 400 });
+	if (!isTextFile(path.basename(filePath)))
+		return NextResponse.json({ error: "Not a text file" }, { status: 400 });
+	try {
+		const buffer = await readFile(filePath);
+		if (buffer.length > MAX_EDIT_SIZE)
+			return NextResponse.json(
+				{ error: "File too large (max 1MB)" },
+				{ status: 413 },
+			);
+		return NextResponse.json({ content: buffer.toString("utf-8") });
+	} catch {
+		return NextResponse.json({ error: "File not found" }, { status: 404 });
+	}
+}
+
+export async function PUT(request: Request) {
+	const body: { path?: string; content?: string } = await request.json();
+	const rel = body.path;
+	const content = body.content;
+	if (!rel || typeof rel !== "string")
+		return NextResponse.json({ error: "Invalid path" }, { status: 400 });
+	if (typeof content !== "string")
+		return NextResponse.json({ error: "Missing content" }, { status: 400 });
+	const filePath = safeRootPath(rel);
+	if (!filePath)
+		return NextResponse.json({ error: "Invalid path" }, { status: 400 });
+	if (!isTextFile(path.basename(filePath)))
+		return NextResponse.json({ error: "Not a text file" }, { status: 400 });
+	try {
+		await mkdir(path.dirname(filePath), { recursive: true });
+		await writeFile(filePath, content, "utf-8");
+		return NextResponse.json({ ok: true });
+	} catch {
+		return NextResponse.json({ error: "Failed to save" }, { status: 500 });
+	}
+}

package/.next/standalone/src/app/api/wiki/file/route.ts

@@ -0,0 +1,52 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { NextResponse } from "next/server";
+import { safeRootPath } from "@/lib/root-dir";
+
+const MIME_MAP: Record<string, string> = {
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	png: "image/png",
+	gif: "image/gif",
+	webp: "image/webp",
+	svg: "image/svg+xml",
+	avif: "image/avif",
+	ico: "image/x-icon",
+	bmp: "image/bmp",
+	pdf: "application/pdf",
+	txt: "text/plain; charset=utf-8",
+	md: "text/markdown; charset=utf-8",
+	mp4: "video/mp4",
+	webm: "video/webm",
+	mov: "video/quicktime",
+	m4v: "video/mp4",
+	mp3: "audio/mpeg",
+	wav: "audio/wav",
+	ogg: "audio/ogg",
+	m4a: "audio/mp4",
+	aac: "audio/aac",
+};
+
+export async function GET(request: Request) {
+	const { searchParams } = new URL(request.url);
+	const rel = searchParams.get("path") ?? "";
+	const filePath = safeRootPath(rel);
+	if (!filePath)
+		return NextResponse.json({ error: "Invalid path" }, { status: 400 });
+	try {
+		const info = await stat(filePath);
+		if (info.isDirectory())
+			return NextResponse.json({ error: "Not a file" }, { status: 400 });
+		const ext = path.extname(filePath).slice(1).toLowerCase();
+		const contentType = MIME_MAP[ext] ?? "application/octet-stream";
+		const buffer = await readFile(filePath);
+		return new Response(buffer, {
+			headers: {
+				"Content-Type": contentType,
+				"Cache-Control": "private, max-age=60",
+			},
+		});
+	} catch {
+		return NextResponse.json({ error: "File not found" }, { status: 404 });
+	}
+}

package/.next/standalone/src/app/api/wiki/folder/route.ts

@@ -0,0 +1,26 @@
+import { mkdir } from "node:fs/promises";
+import { NextResponse } from "next/server";
+import { safeRootPath } from "@/lib/root-dir";
+
+export async function POST(request: Request) {
+	const body: { path?: string } = await request.json();
+	const rel = body.path;
+
+	if (!rel || typeof rel !== "string" || /[<>:"|?*]/.test(rel)) {
+		return NextResponse.json({ error: "Invalid folder path" }, { status: 400 });
+	}
+
+	const folderPath = safeRootPath(rel);
+	if (!folderPath)
+		return NextResponse.json({ error: "Invalid path" }, { status: 400 });
+
+	try {
+		await mkdir(folderPath, { recursive: true });
+		return NextResponse.json({ ok: true });
+	} catch {
+		return NextResponse.json(
+			{ error: "Failed to create folder" },
+			{ status: 500 },
+		);
+	}
+}

package/.next/standalone/src/app/api/wiki/move/route.ts

@@ -0,0 +1,45 @@
+import { rename, stat } from "node:fs/promises";
+import path from "node:path";
+import { NextResponse } from "next/server";
+import { safeRootPath } from "@/lib/root-dir";
+
+export async function POST(request: Request) {
+	const body: { from?: string; to?: string } = await request.json();
+	if (
+		!body.from ||
+		!body.to ||
+		typeof body.from !== "string" ||
+		typeof body.to !== "string"
+	) {
+		return NextResponse.json(
+			{ error: "Missing from/to paths" },
+			{ status: 400 },
+		);
+	}
+
+	const fromPath = safeRootPath(body.from);
+	const toPath = safeRootPath(body.to);
+
+	if (!fromPath || !toPath)
+		return NextResponse.json({ error: "Invalid path" }, { status: 400 });
+
+	if (toPath.startsWith(fromPath + path.sep) || toPath === fromPath) {
+		return NextResponse.json(
+			{ error: "Cannot move a folder into itself" },
+			{ status: 400 },
+		);
+	}
+
+	try {
+		await stat(fromPath);
+	} catch {
+		return NextResponse.json({ error: "Source not found" }, { status: 404 });
+	}
+
+	try {
+		await rename(fromPath, toPath);
+		return NextResponse.json({ ok: true });
+	} catch {
+		return NextResponse.json({ error: "Move failed" }, { status: 500 });
+	}
+}

package/.next/standalone/src/app/api/wiki/page/route.ts

@@ -0,0 +1,84 @@
+import { mkdir, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { NextResponse } from "next/server";
+import { safeRootPath } from "@/lib/root-dir";
+
+const VALID_DIRS = new Set(["entities", "concepts", "comparisons"]);
+const SLUG_RE = /^[a-z0-9-]+$/;
+
+type PageBody = {
+	dir?: string;
+	slug?: string;
+	title?: string;
+};
+
+function humanizeSlug(slug: string): string {
+	return slug
+		.split("-")
+		.filter(Boolean)
+		.map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+		.join(" ");
+}
+
+function dateStampUTC(): string {
+	return new Date().toISOString().slice(0, 10);
+}
+
+function singularType(
+	dir: "entities" | "concepts" | "comparisons",
+): "entity" | "concept" | "comparison" {
+	if (dir === "entities") return "entity";
+	if (dir === "concepts") return "concept";
+	return "comparison";
+}
+
+export async function POST(request: Request) {
+	const body: PageBody = await request.json();
+	const { dir, slug } = body;
+
+	if (!dir || !VALID_DIRS.has(dir)) {
+		return NextResponse.json({ error: "Invalid dir" }, { status: 400 });
+	}
+	if (!slug || !SLUG_RE.test(slug)) {
+		return NextResponse.json({ error: "Invalid slug" }, { status: 400 });
+	}
+
+	const relPath = `${dir}/${slug}.md`;
+	const filePath = safeRootPath(relPath);
+	if (!filePath)
+		return NextResponse.json({ error: "Invalid path" }, { status: 400 });
+
+	try {
+		await stat(filePath);
+		return NextResponse.json(
+			{ error: "Page already exists", path: relPath },
+			{ status: 409 },
+		);
+	} catch (e: unknown) {
+		const code = (e as NodeJS.ErrnoException).code;
+		if (code !== "ENOENT") {
+			return NextResponse.json(
+				{ error: "Failed to create page" },
+				{ status: 500 },
+			);
+		}
+	}
+
+	const safeDir = dir as "entities" | "concepts" | "comparisons";
+	const resolvedTitle =
+		typeof body.title === "string" && body.title.trim().length > 0
+			? body.title
+			: humanizeSlug(slug);
+	const content = `---\ntitle: ${resolvedTitle}\ntype: ${singularType(safeDir)}\ntags: []\nupdated: ${dateStampUTC()}\n---\n\n# ${resolvedTitle}\n\n`;
+
+	try {
+		await mkdir(path.dirname(filePath), { recursive: true });
+		await writeFile(filePath, content, "utf-8");
+		return NextResponse.json({ ok: true, path: relPath, slug, dir: safeDir });
+	} catch {
+		return NextResponse.json(
+			{ error: "Failed to create page" },
+			{ status: 500 },
+		);
+	}
+}

package/.next/standalone/src/app/api/wiki/route.ts

@@ -0,0 +1,98 @@
+import { readdir, rmdir, stat, unlink } from "node:fs/promises";
+import path from "node:path";
+import { NextResponse } from "next/server";
+import { getRootDir, safeRootPath } from "@/lib/root-dir";
+import { isAppFolder, isNodeApp } from "@/lib/wiki-helpers";
+
+export async function GET(request: Request) {
+	const { searchParams } = new URL(request.url);
+	const dir = searchParams.get("dir") ?? "";
+
+	const targetDir = safeRootPath(dir);
+	if (!targetDir)
+		return NextResponse.json({ error: "Invalid path" }, { status: 400 });
+
+	try {
+		let names: string[];
+		try {
+			names = await readdir(targetDir);
+		} catch {
+			return NextResponse.json({ entries: [] });
+		}
+
+		const entries = await Promise.all(
+			names.map(async (name) => {
+				const filePath = path.join(targetDir, name);
+				const info = await stat(filePath);
+				if (info.isDirectory()) {
+					const relPath = dir ? `${dir}/${name}` : name;
+					const nodeApp = await isNodeApp(getRootDir(), relPath);
+					if (nodeApp) {
+						return {
+							name,
+							type: "node-app" as const,
+							modifiedAt: info.mtime.toISOString(),
+						};
+					}
+					const isApp = await isAppFolder(getRootDir(), relPath);
+					return {
+						name,
+						type: (isApp ? "app" : "dir") as "app" | "dir",
+						modifiedAt: info.mtime.toISOString(),
+					};
+				}
+				return {
+					name,
+					type: "file" as const,
+					size: info.size,
+					modifiedAt: info.mtime.toISOString(),
+				};
+			}),
+		);
+
+		entries.sort((a, b) => {
+			const aIsDir = a.type === "dir" || a.type === "app" || a.type === "node-app";
+			const bIsDir = b.type === "dir" || b.type === "app" || b.type === "node-app";
+			if (aIsDir !== bIsDir) return aIsDir ? -1 : 1;
+			return a.name.localeCompare(b.name);
+		});
+
+		return NextResponse.json({ entries });
+	} catch {
+		return NextResponse.json(
+			{ error: "Failed to list directory" },
+			{ status: 500 },
+		);
+	}
+}
+
+export async function DELETE(request: Request) {
+	const body: { path?: string } = await request.json();
+	const rel = body.path;
+	if (!rel || typeof rel !== "string")
+		return NextResponse.json({ error: "Invalid path" }, { status: 400 });
+
+	const filePath = safeRootPath(rel);
+	if (!filePath || filePath === getRootDir())
+		return NextResponse.json({ error: "Invalid path" }, { status: 400 });
+
+	try {
+		const info = await stat(filePath);
+		if (info.isDirectory()) {
+			await rmdir(filePath);
+		} else {
+			await unlink(filePath);
+		}
+		return NextResponse.json({ ok: true });
+	} catch (e: unknown) {
+		const code = (e as NodeJS.ErrnoException).code;
+		if (code === "ENOENT")
+			return NextResponse.json({ error: "Not found" }, { status: 404 });
+		if (code === "ENOTEMPTY")
+			return NextResponse.json(
+				{ error: "Folder is not empty" },
+				{ status: 409 },
+			);
+		return NextResponse.json({ error: "Delete failed" }, { status: 500 });
+	}
+}

package/.next/standalone/src/app/api/wiki/slugs/route.ts

@@ -0,0 +1,50 @@
+import { readdir } from "node:fs/promises";
+import path from "node:path";
+import { NextResponse } from "next/server";
+import { getRootDir } from "@/lib/root-dir";
+
+type SlugBuckets = {
+	entities: string[];
+	concepts: string[];
+	comparisons: string[];
+	root: string[];
+};
+
+async function readMarkdownSlugsFromDir(dirPath: string): Promise<string[]> {
+	try {
+		const entries = await readdir(dirPath, { withFileTypes: true });
+		return entries
+			.filter(
+				(entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".md"),
+			)
+			.map((entry) => entry.name.slice(0, -3))
+			.sort((a, b) => a.localeCompare(b));
+	} catch (e: unknown) {
+		const code = (e as NodeJS.ErrnoException).code;
+		if (code === "ENOENT") return [];
+		throw e;
+	}
+}
+
+export async function GET() {
+	try {
+		// Scan root + known dirs (entities, concepts, comparisons for wiki compat)
+		// plus any other immediate subdirectories
+		const [entities, concepts, comparisons, root] = await Promise.all([
+			readMarkdownSlugsFromDir(path.join(getRootDir(), "entities")),
+			readMarkdownSlugsFromDir(path.join(getRootDir(), "concepts")),
+			readMarkdownSlugsFromDir(path.join(getRootDir(), "comparisons")),
+			readMarkdownSlugsFromDir(getRootDir()),
+		]);
+
+		const body: SlugBuckets = { entities, concepts, comparisons, root };
+		return NextResponse.json(body, {
+			headers: { "Cache-Control": "private, max-age=10" },
+		});
+	} catch {
+		return NextResponse.json(
+			{ error: "Failed to list slugs" },
+			{ status: 500 },
+		);
+	}
+}

package/.next/standalone/src/app/api/wiki/upload/route.ts

@@ -0,0 +1,87 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { NextResponse } from "next/server";
+import { safeRootPath } from "@/lib/root-dir";
+
+const ALLOWED_MIME_TYPES = new Set([
+	"application/pdf",
+	"text/plain",
+	"text/markdown",
+	"application/msword",
+	"application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+	"application/vnd.ms-excel",
+	"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+	"application/vnd.ms-powerpoint",
+	"application/vnd.openxmlformats-officedocument.presentationml.presentation",
+	"image/jpeg",
+	"image/png",
+	"image/gif",
+	"image/webp",
+	"image/svg+xml",
+	"application/octet-stream",
+]);
+
+const ALLOWED_EXTENSIONS = new Set([
+	"pdf", "txt", "md", "doc", "docx", "xls", "xlsx", "ppt", "pptx",
+	"jpg", "jpeg", "png", "gif", "webp", "svg", "csv", "json",
+	"yaml", "yml", "xml", "html", "sh", "mp4", "webm", "mov",
+	"mp3", "wav", "ogg", "m4a", "aac", "ipynb", "mmd",
+]);
+
+const MAX_SIZE_BYTES = 100 * 1024 * 1024; // 100MB
+
+function sanitizeFilename(name: string): string {
+	return name.replace(/[^a-zA-Z0-9._-]/g, "_").replace(/_{2,}/g, "_");
+}
+
+export async function POST(request: Request) {
+	let formData: FormData;
+	try {
+		formData = await request.formData();
+	} catch {
+		return NextResponse.json({ error: "Invalid form data" }, { status: 400 });
+	}
+
+	const file = formData.get("file");
+	if (!file || !(file instanceof File))
+		return NextResponse.json({ error: "No file provided" }, { status: 400 });
+
+	const dir = (formData.get("dir") as string) ?? "";
+	const targetDir = safeRootPath(dir);
+	if (!targetDir)
+		return NextResponse.json({ error: "Invalid directory" }, { status: 400 });
+
+	const fileExt = file.name.split(".").pop()?.toLowerCase() ?? "";
+	if (!ALLOWED_MIME_TYPES.has(file.type) && !ALLOWED_EXTENSIONS.has(fileExt)) {
+		return NextResponse.json(
+			{ error: `File type not allowed: ${file.name}` },
+			{ status: 400 },
+		);
+	}
+
+	if (file.size > MAX_SIZE_BYTES) {
+		return NextResponse.json(
+			{ error: "File exceeds 100MB limit" },
+			{ status: 400 },
+		);
+	}
+
+	const baseName = sanitizeFilename(file.name.replace(/\.[^.]+$/, ""));
+	const savedFilename = `${baseName}.${fileExt}`;
+	const filePath = path.join(targetDir, savedFilename);
+
+	try {
+		await mkdir(targetDir, { recursive: true });
+		const buffer = Buffer.from(await file.arrayBuffer());
+		await writeFile(filePath, buffer);
+	} catch {
+		return NextResponse.json({ error: "Failed to save file" }, { status: 500 });
+	}
+
+	const relPath = dir ? `${dir}/${savedFilename}` : savedFilename;
+	return NextResponse.json({
+		filename: savedFilename,
+		path: relPath,
+		originalName: file.name,
+	});
+}