wiki-viewer 1.0.0

package/.next/standalone/pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+allowBuilds:
+  sharp: set this to true or false

package/.next/standalone/postcss.config.mjs

@@ -0,0 +1,2 @@
+const config = { plugins: { tailwindcss: {}, autoprefixer: {} } };
+export default config;

package/.next/standalone/public/logo.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+  <rect x="15" y="15" width="70" height="70" rx="8" fill="#292524"/>
+
+  <rect x="23" y="29" width="46" height="8" rx="2" fill="#ffffff"/>
+  <rect x="23" y="45" width="34" height="8" rx="2" fill="#ffffff"/>
+
+  <rect x="23" y="61" width="16" height="8" rx="2" fill="#ffffff"/>
+  <rect x="43" y="61" width="28" height="8" rx="2" fill="#ffffff"/>
+
+  <path d="M 69 57 L 78 65 L 69 73 Z" fill="#ffffff"/>
+</svg>

package/.next/standalone/public/public/logo.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+  <rect x="15" y="15" width="70" height="70" rx="8" fill="#292524"/>
+
+  <rect x="23" y="29" width="46" height="8" rx="2" fill="#ffffff"/>
+  <rect x="23" y="45" width="34" height="8" rx="2" fill="#ffffff"/>
+
+  <rect x="23" y="61" width="16" height="8" rx="2" fill="#ffffff"/>
+  <rect x="43" y="61" width="28" height="8" rx="2" fill="#ffffff"/>
+
+  <path d="M 69 57 L 78 65 L 69 73 Z" fill="#ffffff"/>
+</svg>

package/.next/standalone/server.js

@@ -0,0 +1,44 @@
+performance.mark('next-start');
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import module from 'node:module'
+const require = module.createRequire(import.meta.url)
+const __dirname = fileURLToPath(new URL('.', import.meta.url))
+
+
+const dir = path.join(__dirname)
+
+process.env.NODE_ENV = 'production'
+process.chdir(__dirname)
+
+const currentPort = parseInt(process.env.PORT, 10) || 3000
+const hostname = process.env.HOSTNAME || '0.0.0.0'
+
+let keepAliveTimeout = parseInt(process.env.KEEP_ALIVE_TIMEOUT, 10)
+const nextConfig = {"env":{},"webpack":null,"typescript":{"ignoreBuildErrors":false},"typedRoutes":false,"distDir":"./.next","cleanDistDir":true,"assetPrefix":"","cacheMaxMemorySize":52428800,"configOrigin":"next.config.ts","useFileSystemPublicRoutes":true,"generateEtags":true,"pageExtensions":["tsx","ts","jsx","js"],"poweredByHeader":true,"compress":true,"images":{"deviceSizes":[640,750,828,1080,1200,1920,2048,3840],"imageSizes":[32,48,64,96,128,256,384],"path":"/_next/image","loader":"default","loaderFile":"","domains":[],"disableStaticImages":false,"minimumCacheTTL":14400,"formats":["image/webp"],"maximumRedirects":3,"maximumResponseBody":50000000,"dangerouslyAllowLocalIP":false,"dangerouslyAllowSVG":false,"contentSecurityPolicy":"script-src 'none'; frame-src 'none'; sandbox;","contentDispositionType":"attachment","localPatterns":[{"pathname":"**","search":""}],"remotePatterns":[],"qualities":[75],"unoptimized":false,"customCacheHandler":false},"devIndicators":{"position":"bottom-left"},"onDemandEntries":{"maxInactiveAge":60000,"pagesBufferLength":5},"basePath":"","sassOptions":{},"trailingSlash":false,"i18n":null,"productionBrowserSourceMaps":false,"excludeDefaultMomentLocales":true,"reactProductionProfiling":false,"reactStrictMode":null,"reactMaxHeadersLength":6000,"httpAgentOptions":{"keepAlive":true},"logging":{"serverFunctions":true,"browserToTerminal":"warn"},"compiler":{},"expireTime":31536000,"staticPageGenerationTimeout":60,"output":"standalone","modularizeImports":{"@mui/icons-material":{"transform":"@mui/icons-material/{{member}}"},"lodash":{"transform":"lodash/{{member}}"}},"outputFileTracingRoot":"/home/sil/wiki-viewer","allowedDevOrigins":["devvm"],"cacheComponents":false,"cacheLife":{"default":{"stale":300,"revalidate":900,"expire":4294967294},"seconds":{"stale":30,"revalidate":1,"expire":60},"minutes":{"stale":300,"revalidate":60,"expire":3600},"hours":{"stale":300,"revalidate":3600,"expire":86400},"days":{"stale":300,"revalidate":86400,"expire":604800},"weeks":{"stale":300,"revalidate":604800,"expire":2592000},"max":{"stale":300,"revalidate":2592000,"expire":31536000}},"cacheHandlers":{},"experimental":{"appNewScrollHandler":false,"useSkewCookie":false,"cssChunking":true,"multiZoneDraftMode":false,"appNavFailHandling":false,"prerenderEarlyExit":true,"serverMinification":true,"linkNoTouchStart":false,"caseSensitiveRoutes":false,"cachedNavigations":false,"partialFallbacks":false,"dynamicOnHover":false,"varyParams":false,"prefetchInlining":false,"preloadEntriesOnStart":true,"clientRouterFilter":true,"clientRouterFilterRedirects":false,"fetchCacheKeyPrefix":"","proxyPrefetch":"flexible","optimisticClientCache":true,"manualClientBasePath":false,"cpus":3,"memoryBasedWorkersCount":false,"imgOptConcurrency":null,"imgOptTimeoutInSeconds":7,"imgOptMaxInputPixels":268402689,"imgOptSequentialRead":null,"imgOptSkipMetadata":null,"isrFlushToDisk":true,"workerThreads":false,"optimizeCss":false,"nextScriptWorkers":false,"scrollRestoration":false,"externalDir":false,"disableOptimizedLoading":false,"gzipSize":true,"craCompat":false,"esmExternals":true,"fullySpecified":false,"swcTraceProfiling":false,"forceSwcTransforms":false,"largePageDataBytes":128000,"typedEnv":false,"parallelServerCompiles":false,"parallelServerBuildTraces":false,"ppr":false,"authInterrupts":false,"webpackMemoryOptimizations":false,"optimizeServerReact":true,"strictRouteTypes":false,"viewTransition":false,"removeUncaughtErrorAndRejectionListeners":false,"validateRSCRequestHeaders":false,"staleTimes":{"dynamic":0,"static":300},"reactDebugChannel":true,"serverComponentsHmrCache":true,"staticGenerationMaxConcurrency":8,"staticGenerationMinPagesPerWorker":25,"transitionIndicator":false,"gestureTransition":false,"inlineCss":false,"useCache":false,"globalNotFound":false,"browserDebugInfoInTerminal":"warn","lockDistDir":true,"proxyClientMaxBodySize":10485760,"hideLogsAfterAbort":false,"mcpServer":true,"turbopackFileSystemCacheForDev":true,"turbopackFileSystemCacheForBuild":false,"turbopackInferModuleSideEffects":true,"turbopackPluginRuntimeStrategy":"childProcesses","optimizePackageImports":["lucide-react","date-fns","lodash-es","ramda","antd","react-bootstrap","ahooks","@ant-design/icons","@headlessui/react","@headlessui-float/react","@heroicons/react/20/solid","@heroicons/react/24/solid","@heroicons/react/24/outline","@visx/visx","@tremor/react","rxjs","@mui/material","@mui/icons-material","recharts","react-use","effect","@effect/schema","@effect/platform","@effect/platform-node","@effect/platform-browser","@effect/platform-bun","@effect/sql","@effect/sql-mssql","@effect/sql-mysql2","@effect/sql-pg","@effect/sql-sqlite-node","@effect/sql-sqlite-bun","@effect/sql-sqlite-wasm","@effect/sql-sqlite-react-native","@effect/rpc","@effect/rpc-http","@effect/typeclass","@effect/experimental","@effect/opentelemetry","@material-ui/core","@material-ui/icons","@tabler/icons-react","mui-core","react-icons/ai","react-icons/bi","react-icons/bs","react-icons/cg","react-icons/ci","react-icons/di","react-icons/fa","react-icons/fa6","react-icons/fc","react-icons/fi","react-icons/gi","react-icons/go","react-icons/gr","react-icons/hi","react-icons/hi2","react-icons/im","react-icons/io","react-icons/io5","react-icons/lia","react-icons/lib","react-icons/lu","react-icons/md","react-icons/pi","react-icons/ri","react-icons/rx","react-icons/si","react-icons/sl","react-icons/tb","react-icons/tfi","react-icons/ti","react-icons/vsc","react-icons/wi"],"trustHostHeader":false,"isExperimentalCompile":false},"htmlLimitedBots":"[\\w-]+-Google|Google-[\\w-]+|Chrome-Lighthouse|Slurp|DuckDuckBot|baiduspider|yandex|sogou|bitlybot|tumblr|vkShare|quora link preview|redditbot|ia_archiver|Bingbot|BingPreview|applebot|facebookexternalhit|facebookcatalog|Twitterbot|LinkedInBot|Slackbot|Discordbot|WhatsApp|SkypeUriPreview|Yeti|googleweblight","bundlePagesRouterDependencies":false,"configFileName":"next.config.ts","turbopack":{"root":"/home/sil/wiki-viewer"},"distDirRoot":".next"}
+
+process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(nextConfig)
+
+require('next')
+const { startServer } = require('next/dist/server/lib/start-server')
+
+if (
+  Number.isNaN(keepAliveTimeout) ||
+  !Number.isFinite(keepAliveTimeout) ||
+  keepAliveTimeout < 0
+) {
+  keepAliveTimeout = undefined
+}
+
+startServer({
+  dir,
+  isDev: false,
+  config: nextConfig,
+  hostname,
+  port: currentPort,
+  allowRetry: false,
+  keepAliveTimeout,
+}).catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

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

@@ -0,0 +1,247 @@
+/**
+ * Reverse proxy for node-app directories — built on undici.request()
+ *
+ * Unlike fetch(), undici.request() does NOT auto-decompress, so compressed
+ * assets (gzip/br) stream through with their Content-Encoding intact and the
+ * browser handles decompression itself. No ERR_CONTENT_DECODING_FAILED.
+ *
+ * For HTML/CSS (which we rewrite) we force accept-encoding:identity upstream
+ * so we always receive plain text we can safely manipulate.
+ */
+import { Readable } from "node:stream";
+import { request as undiciRequest } from "undici";
+import type { Dispatcher } from "undici";
+import { NextResponse } from "next/server";
+import { resolveByPrefix } from "@/lib/app-runner";
+
+const HOP_BY_HOP = new Set([
+	"connection", "keep-alive", "proxy-authenticate", "proxy-authorization",
+	"te", "trailers", "transfer-encoding", "upgrade",
+]);
+
+// ── service worker ────────────────────────────────────────────────────────────
+
+function makeServiceWorker(proxyBase: string): string {
+	return `
+/* wiki-viewer injected service worker */
+const BASE = ${JSON.stringify(proxyBase)};
+self.addEventListener("install", () => self.skipWaiting());
+self.addEventListener("activate", (e) => e.waitUntil(self.clients.claim()));
+self.addEventListener("fetch", (event) => {
+  const url = new URL(event.request.url);
+  if (url.origin !== self.location.origin) return;
+  if (url.pathname.startsWith(BASE + "/")) return;
+  if (url.pathname === BASE + "/sw-proxy.js") return;
+  event.respondWith(fetch(BASE + url.pathname + url.search, {
+    method: event.request.method,
+    headers: event.request.headers,
+    body: ["GET","HEAD"].includes(event.request.method) ? undefined : event.request.body,
+    credentials: event.request.credentials,
+  }));
+});`.trim();
+}
+
+// ── rewriters ─────────────────────────────────────────────────────────────────
+
+function rewriteHtml(html: string, proxyBase: string): string {
+	let out = html;
+	out = out.replace(/((?:src|href|action|data-src|data-href|content)=")\/(?!\/)/g, `$1${proxyBase}/`);
+	out = out.replace(/(srcset="[^"]*)\/(?!\/)/g, `$1${proxyBase}/`);
+	out = out.replace(/(<head(?:\s[^>]*)?>)/i, `$1\n<base href="${proxyBase}/">`);
+	// Inject before </head>. Works without service workers (non-localhost HTTP):
+	//
+	// 1. replaceState — strips the proxy prefix from the initial URL so
+	//    BrowserRouter sees "/" instead of "/api/app-proxy/apps/X"
+	// 2. fetch/XHR overrides — rewrite absolute-path calls (/api/...) through
+	//    the proxy so they reach the upstream app, not wiki-viewer
+	// 3. SW — best-effort (only works on localhost/HTTPS), provides navigation
+	//    interception for hard-refreshes on sub-routes
+	const patches = `<script>
+(function(){
+  var BASE = ${JSON.stringify(proxyBase)};
+  // 1. Normalize initial URL: BrowserRouter will see "/" not "/api/app-proxy/apps/X"
+  var _loc = location.pathname;
+  if (_loc.startsWith(BASE)) {
+    history.replaceState(history.state, '', _loc.slice(BASE.length) || '/');
+  }
+  // 2. Rewrite fetch() absolute paths through proxy (works on non-localhost HTTP)
+  var _fetch = window.fetch;
+  window.fetch = function(input, init) {
+    if (typeof input === 'string' && input.startsWith('/') && !input.startsWith('/api/app-proxy/')) {
+      input = BASE + input;
+    }
+    return _fetch.call(window, input, init);
+  };
+  // 3. Rewrite XMLHttpRequest absolute paths
+  var _xhrOpen = XMLHttpRequest.prototype.open;
+  XMLHttpRequest.prototype.open = function(method, url) {
+    if (typeof url === 'string' && url.startsWith('/') && !url.startsWith('/api/app-proxy/')) {
+      url = BASE + url;
+    }
+    return _xhrOpen.apply(this, [method, url].concat(Array.prototype.slice.call(arguments, 2)));
+  };
+  // 4. SW — best-effort for localhost/HTTPS; reloads once on first activation
+  if ('serviceWorker' in navigator) {
+    if (!navigator.serviceWorker.controller) {
+      navigator.serviceWorker.addEventListener('controllerchange', function() {
+        window.location.reload();
+      }, { once: true });
+    }
+    navigator.serviceWorker.register(BASE + '/sw-proxy.js?v=2', { scope: BASE + '/' })
+      .catch(function(){});
+  }
+})();
+</script>`;
+	out = out.replace(/<\/head>/i, `${patches}\n</head>`);
+	return out;
+}
+
+function rewriteCss(css: string, proxyBase: string): string {
+	return css.replace(/url\((['"]?)\/(?!\/)/g, `url($1${proxyBase}/`);
+}
+
+// ── header helpers ────────────────────────────────────────────────────────────
+
+function upstreamHeaders(
+	src: Headers,
+	port: number,
+	reqUrl: URL,
+	forceIdentity = false,
+): Record<string, string> {
+	const out: Record<string, string> = {};
+	for (const [k, v] of src.entries()) {
+		if (HOP_BY_HOP.has(k.toLowerCase())) continue;
+		out[k] = v;
+	}
+	out["host"] = `localhost:${port}`;
+	out["x-forwarded-host"] = reqUrl.host;
+	out["x-forwarded-proto"] = reqUrl.protocol.replace(":", "");
+	if (forceIdentity) out["accept-encoding"] = "identity";
+	return out;
+}
+
+function buildResHeaders(raw: Dispatcher.ResponseData["headers"]): Headers {
+	const out = new Headers();
+	for (const [k, v] of Object.entries(raw)) {
+		if (!v || HOP_BY_HOP.has(k.toLowerCase())) continue;
+		const vals = Array.isArray(v) ? v : [v];
+		for (const val of vals) out.append(k, val);
+	}
+	return out;
+}
+
+// ── handler ───────────────────────────────────────────────────────────────────
+
+async function handleProxy(
+	request: Request,
+	{ params }: { params: Promise<{ path: string[] }> },
+): Promise<Response> {
+	const segments = (await params).path ?? [];
+	const reqUrl = new URL(request.url);
+
+	const resolved = resolveByPrefix(segments);
+	if (!resolved) {
+		return NextResponse.json(
+			{ error: "App not running — launch it first in wiki-viewer." },
+			{ status: 503 },
+		);
+	}
+
+	const { port, relPath, rest } = resolved;
+	const proxyBase = `/api/app-proxy/${relPath}`;
+
+	if (rest === "/sw-proxy.js") {
+		return new Response(makeServiceWorker(proxyBase), {
+			status: 200,
+			headers: {
+				"content-type": "application/javascript; charset=utf-8",
+				"service-worker-allowed": proxyBase + "/",
+				"cache-control": "no-store",
+			},
+		});
+	}
+
+	const upstreamUrl = `http://localhost:${port}${rest}${reqUrl.search}`;
+	const method = request.method as Dispatcher.HttpMethod;
+	const isBodyless = ["GET", "HEAD"].includes(request.method);
+
+	try {
+		// First pass with normal headers to discover content-type
+		const first = await undiciRequest(upstreamUrl, {
+			method,
+			headers: upstreamHeaders(request.headers, port, reqUrl),
+			body: isBodyless ? null : (request.body as unknown as Readable),
+		});
+
+		const contentType = String(first.headers["content-type"] ?? "");
+		const needsRewrite = contentType.includes("text/html") || contentType.includes("text/css");
+
+		if (needsRewrite) {
+			// Drain first response and re-fetch with identity encoding for plain text
+			first.body.resume();
+			const second = await undiciRequest(upstreamUrl, {
+				method: isBodyless ? method : "GET",
+				headers: upstreamHeaders(request.headers, port, reqUrl, true),
+				body: null,
+			});
+			const text = await second.body.text();
+			const resHeaders = buildResHeaders(second.headers);
+			// Body changed size after rewriting — drop these or client truncates
+			resHeaders.delete("content-encoding");
+			resHeaders.delete("content-length");
+
+			if (contentType.includes("text/html")) {
+				resHeaders.set("content-type", "text/html; charset=utf-8");
+				return new Response(rewriteHtml(text, proxyBase), { status: second.statusCode, headers: resHeaders });
+			}
+			resHeaders.set("content-type", contentType);
+			return new Response(rewriteCss(text, proxyBase), { status: second.statusCode, headers: resHeaders });
+		}
+
+		// SPA fallback: if upstream returns 404 for a path with no file extension
+		// (i.e. a client-side route), re-fetch "/" and return index.html so the
+		// SPA's router can handle it client-side.
+		const hasExt = /\.[a-z0-9]{1,8}$/i.test(rest.split("?")[0]);
+		if (first.statusCode === 404 && !hasExt) {
+			first.body.resume();
+			const fallback = await undiciRequest(`http://localhost:${port}/`, {
+				method: "GET",
+				headers: upstreamHeaders(request.headers, port, reqUrl, true),
+				body: null,
+			});
+			const fallbackText = await fallback.body.text();
+			const fallbackHeaders = buildResHeaders(fallback.headers);
+			fallbackHeaders.delete("content-encoding");
+			fallbackHeaders.delete("content-length");
+			fallbackHeaders.set("content-type", "text/html; charset=utf-8");
+			return new Response(rewriteHtml(fallbackText, proxyBase), {
+				status: 200,
+				headers: fallbackHeaders,
+			});
+		}
+
+		// 304/204/205: null-body statuses — Response constructor rejects a stream body
+		if (new Set([101, 204, 205, 304]).has(first.statusCode)) {
+			first.body.resume();
+			return new Response(null, { status: first.statusCode, headers: buildResHeaders(first.headers) });
+		}
+
+		// Stream everything else — compressed bytes + Content-Encoding flow through intact
+		return new Response(Readable.toWeb(first.body) as ReadableStream, {
+			status: first.statusCode,
+			headers: buildResHeaders(first.headers),
+		});
+
+	} catch (e) {
+		return NextResponse.json({ error: `Upstream unreachable: ${e}` }, { status: 502 });
+	}
+}
+
+export const GET = handleProxy;
+export const POST = handleProxy;
+export const PUT = handleProxy;
+export const DELETE = handleProxy;
+export const PATCH = handleProxy;
+export const HEAD = handleProxy;
+export const OPTIONS = handleProxy;
+export const dynamic = "force-dynamic";

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

@@ -0,0 +1,70 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { NextResponse } from "next/server";
+import { getRootDir } 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",
+	ipynb: "application/json",
+	json: "application/json",
+	js: "text/javascript",
+	ts: "text/plain",
+	css: "text/css",
+	html: "text/html",
+	mmd: "text/plain",
+	docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+	xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+	pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+};
+
+export async function GET(
+	_request: Request,
+	{ params }: { params: Promise<{ path: string[] }> },
+) {
+	const segments = (await params).path;
+	const rel = segments.join("/");
+
+	// Path traversal guard
+	const resolved = path.resolve(getRootDir(), rel);
+	if (resolved !== getRootDir() && !resolved.startsWith(getRootDir() + path.sep)) {
+		return NextResponse.json({ error: "Invalid path" }, { status: 400 });
+	}
+
+	try {
+		const info = await stat(resolved);
+		if (info.isDirectory())
+			return NextResponse.json({ error: "Not a file" }, { status: 400 });
+
+		const ext = path.extname(resolved).slice(1).toLowerCase();
+		const contentType = MIME_MAP[ext] ?? "application/octet-stream";
+		const buffer = await readFile(resolved);
+		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/system/browse/route.ts

@@ -0,0 +1,78 @@
+import { readdir, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { NextResponse } from "next/server";
+
+interface BrowseEntry {
+	name: string;
+	path: string;
+	accessible: boolean;
+}
+
+export async function GET(request: Request) {
+	const { searchParams } = new URL(request.url);
+	const rawPath = searchParams.get("path");
+
+	// Default to home dir
+	const target = rawPath ? path.resolve(rawPath) : os.homedir();
+
+	// Verify it's a directory
+	try {
+		const info = await stat(target);
+		if (!info.isDirectory()) {
+			return NextResponse.json({ error: "Not a directory" }, { status: 400 });
+		}
+	} catch {
+		return NextResponse.json({ error: "Path not found" }, { status: 404 });
+	}
+
+	// List entries — only directories
+	let entries: BrowseEntry[] = [];
+	try {
+		const names = await readdir(target);
+		const infos = await Promise.allSettled(
+			names.map(async (name) => {
+				const full = path.join(target, name);
+				const info = await stat(full);
+				return { name, full, isDir: info.isDirectory() };
+			}),
+		);
+		entries = infos
+			.filter(
+				(r): r is PromiseFulfilledResult<{ name: string; full: string; isDir: boolean }> =>
+					r.status === "fulfilled" && r.value.isDir,
+			)
+			.map((r) => ({ name: r.value.name, path: r.value.full, accessible: true }))
+			.sort((a, b) => a.name.localeCompare(b.name));
+	} catch {
+		// Permission denied or similar — return empty list but still allow selection
+	}
+
+	// Parent path (null at filesystem root)
+	const parent = target === path.parse(target).root ? null : path.dirname(target);
+
+	// Quick-access shortcuts
+	const home = os.homedir();
+	const shortcuts = [
+		{ label: "Home", path: home },
+		{ label: "Root", path: "/" },
+	];
+	// Add common paths that exist
+	for (const [label, p] of [
+		["Desktop", path.join(home, "Desktop")],
+		["Documents", path.join(home, "Documents")],
+		["Downloads", path.join(home, "Downloads")],
+	] as [string, string][]) {
+		try {
+			await stat(p);
+			shortcuts.push({ label, path: p });
+		} catch {}
+	}
+
+	return NextResponse.json({
+		path: target,
+		parent,
+		entries,
+		shortcuts,
+	});
+}

package/.next/standalone/src/app/api/system/clear-root/route.ts

@@ -0,0 +1,9 @@
+import { NextResponse } from "next/server";
+import { writeConfig } from "@/lib/config";
+import { clearRootDir } from "@/lib/root-dir";
+
+export async function POST() {
+	clearRootDir();
+	await writeConfig({ lastOpenedPath: undefined });
+	return NextResponse.json({ ok: true });
+}

package/.next/standalone/src/app/api/system/config/route.ts

@@ -0,0 +1,10 @@
+import { NextResponse } from "next/server";
+import { readConfig } from "@/lib/config";
+
+export async function GET() {
+	const config = await readConfig();
+	return NextResponse.json({
+		pinnedPaths: config.pinnedPaths ?? [],
+		lastOpenedPath: config.lastOpenedPath ?? null,
+	});
+}

package/.next/standalone/src/app/api/system/pins/route.ts

@@ -0,0 +1,31 @@
+import { stat } from "node:fs/promises";
+import { NextResponse } from "next/server";
+import { readConfig, writeConfig } from "@/lib/config";
+
+export async function POST(request: Request) {
+	const body: { path?: string; action?: "pin" | "unpin" } = await request.json();
+	const p = body.path?.trim();
+	const action = body.action ?? "pin";
+	if (!p) return NextResponse.json({ error: "Missing path" }, { status: 400 });
+
+	if (action === "pin") {
+		try {
+			const info = await stat(p);
+			if (!info.isDirectory())
+				return NextResponse.json({ error: "Not a directory" }, { status: 400 });
+		} catch {
+			return NextResponse.json({ error: "Path not found" }, { status: 404 });
+		}
+		const config = await readConfig();
+		const pins = config.pinnedPaths ?? [];
+		if (!pins.includes(p)) {
+			await writeConfig({ pinnedPaths: [...pins, p] });
+		}
+	} else {
+		const config = await readConfig();
+		const pins = (config.pinnedPaths ?? []).filter((x) => x !== p);
+		await writeConfig({ pinnedPaths: pins });
+	}
+
+	return NextResponse.json({ ok: true });
+}

package/.next/standalone/src/app/api/system/reveal/route.ts

@@ -0,0 +1,28 @@
+import { exec } from "node:child_process";
+import path from "node:path";
+import { NextResponse } from "next/server";
+import { getRootDir } 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")
+		return NextResponse.json({ error: "Invalid path" }, { status: 400 });
+
+	// Path traversal guard
+	const resolved = path.resolve(getRootDir(), rel);
+	if (resolved !== getRootDir() && !resolved.startsWith(getRootDir() + path.sep))
+		return NextResponse.json({ error: "Invalid path" }, { status: 400 });
+
+	// Open in system file manager
+	const platform = process.platform;
+	const cmd =
+		platform === "darwin"
+			? `open -R "${resolved}"`
+			: platform === "win32"
+				? `explorer /select,"${resolved}"`
+				: `xdg-open "${path.dirname(resolved)}"`;
+
+	exec(cmd, () => {});
+	return NextResponse.json({ ok: true });
+}

package/.next/standalone/src/app/api/system/root-status/route.ts

@@ -0,0 +1,9 @@
+import { NextResponse } from "next/server";
+import { getRootDir, isRootDirSet } from "@/lib/root-dir";
+
+export async function GET() {
+	return NextResponse.json({
+		configured: isRootDirSet(),
+		path: isRootDirSet() ? getRootDir() : null,
+	});
+}

package/.next/standalone/src/app/api/system/set-root/route.ts

@@ -0,0 +1,23 @@
+import { stat } from "node:fs/promises";
+import { NextResponse } from "next/server";
+import { writeConfig } from "@/lib/config";
+import { setRootDir } from "@/lib/root-dir";
+
+export async function POST(request: Request) {
+	const body: { path?: string } = await request.json();
+	const dir = body.path?.trim();
+	if (!dir) return NextResponse.json({ error: "Missing path" }, { status: 400 });
+
+	// Verify it exists and is a directory
+	try {
+		const info = await stat(dir);
+		if (!info.isDirectory())
+			return NextResponse.json({ error: "Not a directory" }, { status: 400 });
+	} catch {
+		return NextResponse.json({ error: "Directory not found" }, { status: 404 });
+	}
+
+	setRootDir(dir);
+	await writeConfig({ lastOpenedPath: dir });
+	return NextResponse.json({ ok: true, path: dir });
+}