wiki-viewer 1.0.0

package/.next/standalone/src/components/wiki/frontmatter-header.tsx

@@ -0,0 +1,164 @@
+"use client";
+import { ChevronDown, ChevronRight } from "lucide-react";
+import { Fragment, useState } from "react";
+import { Badge } from "@/components/ui/badge";
+
+type FmValue =
+	| string
+	| number
+	| boolean
+	| string[]
+	| Record<string, unknown>
+	| null;
+
+interface Props {
+	data: Record<string, FmValue>;
+}
+
+const KNOWN_KEYS = new Set([
+	"title",
+	"type",
+	"status",
+	"created",
+	"updated",
+	"date",
+	"tags",
+	"sources",
+	"private",
+	"supersedes",
+	"superseded_by",
+]);
+
+function fmt(v: unknown): string {
+	if (v === null || v === undefined) return "";
+	if (typeof v === "string") return v;
+	if (typeof v === "number" || typeof v === "boolean") return String(v);
+	if (Array.isArray(v)) return v.map(fmt).join(", ");
+	try {
+		return JSON.stringify(v);
+	} catch {
+		return String(v);
+	}
+}
+
+export function FrontmatterHeader({ data }: Props) {
+	const [showRaw, setShowRaw] = useState(false);
+	const keys = Object.keys(data);
+	if (keys.length === 0) return null;
+
+	const title = typeof data.title === "string" ? data.title : null;
+	const type = typeof data.type === "string" ? data.type : null;
+	const status = typeof data.status === "string" ? data.status : null;
+	const created = typeof data.created === "string" ? data.created : null;
+	const updated = typeof data.updated === "string" ? data.updated : null;
+	const isPrivate = data.private === true;
+	const tags = Array.isArray(data.tags) ? (data.tags as string[]) : [];
+	const sources = Array.isArray(data.sources) ? (data.sources as string[]) : [];
+	const supersededBy =
+		typeof data.superseded_by === "string" ? data.superseded_by : null;
+
+	const otherKeys = keys.filter((k) => !KNOWN_KEYS.has(k));
+
+	return (
+		<div className="mb-6 rounded-sm border bg-card/40 px-4 py-3 text-xs">
+			{title && (
+				<div className="mb-2 text-base font-normal text-foreground">
+					{title}
+				</div>
+			)}
+
+			<div className="flex flex-wrap items-center gap-x-3 gap-y-1.5 text-muted-foreground">
+				{type && (
+					<Badge variant="outline" className="font-normal">
+						{type}
+					</Badge>
+				)}
+				{status && (
+					<Badge variant="outline" className="font-normal">
+						{status}
+					</Badge>
+				)}
+				{isPrivate && (
+					<Badge
+						variant="outline"
+						className="border-warning-ink/40 font-normal text-warning-ink"
+					>
+						private
+					</Badge>
+				)}
+				{supersededBy && (
+					<Badge
+						variant="outline"
+						className="border-destructive/40 font-normal text-destructive"
+					>
+						superseded → {supersededBy}
+					</Badge>
+				)}
+				{created && (
+					<span>
+						<span className="opacity-60">created</span>{" "}
+						<span className="text-foreground/80">{created}</span>
+					</span>
+				)}
+				{updated && updated !== created && (
+					<span>
+						<span className="opacity-60">updated</span>{" "}
+						<span className="text-foreground/80">{updated}</span>
+					</span>
+				)}
+			</div>
+
+			{tags.length > 0 && (
+				<div className="mt-2 flex flex-wrap gap-1">
+					{tags.map((t) => (
+						<Badge
+							key={t}
+							variant="secondary"
+							className="font-normal text-[11px]"
+						>
+							#{t}
+						</Badge>
+					))}
+				</div>
+			)}
+
+			{sources.length > 0 && (
+				<div className="mt-2">
+					<span className="opacity-60">sources:</span>{" "}
+					<span className="text-foreground/80">{sources.join(", ")}</span>
+				</div>
+			)}
+
+			{otherKeys.length > 0 && (
+				<div className="mt-2 border-t pt-2">
+					<button
+						type="button"
+						onClick={() => setShowRaw((v) => !v)}
+						className="flex items-center gap-1 text-muted-foreground hover:text-foreground"
+					>
+						{showRaw ? (
+							<ChevronDown className="h-3 w-3" />
+						) : (
+							<ChevronRight className="h-3 w-3" />
+						)}
+						<span>
+							{otherKeys.length} more field{otherKeys.length === 1 ? "" : "s"}
+						</span>
+					</button>
+					{showRaw && (
+						<dl className="mt-1.5 grid grid-cols-[max-content_1fr] gap-x-3 gap-y-0.5">
+							{otherKeys.map((k) => (
+								<Fragment key={k}>
+									<dt className="opacity-60">{k}</dt>
+									<dd className="text-foreground/80 break-words">
+										{fmt(data[k])}
+									</dd>
+								</Fragment>
+							))}
+						</dl>
+					)}
+				</div>
+			)}
+		</div>
+	);
+}

package/.next/standalone/src/lib/app-runner.ts

@@ -0,0 +1,231 @@
+/**
+ * Server-side singleton that manages child processes for node-app directories.
+ * Lives as a module-level Map so it persists across requests in both dev and
+ * the Next.js standalone production server.
+ */
+import { spawn, type ChildProcess, execSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { createConnection, createServer } from "node:net";
+import path from "node:path";
+
+export type AppStatus = "stopped" | "installing" | "starting" | "running" | "error";
+
+interface RunningApp {
+	port: number;
+	process: ChildProcess | null;
+	status: AppStatus;
+	error?: string;
+	logs: string[];
+}
+
+// ── singleton ────────────────────────────────────────────────────────────────
+const apps = new Map<string, RunningApp>();
+
+// ── helpers ──────────────────────────────────────────────────────────────────
+
+function findFreePort(): Promise<number> {
+	return new Promise((resolve, reject) => {
+		const s = createServer();
+		s.listen(0, "127.0.0.1", () => {
+			const addr = s.address();
+			const port = typeof addr === "object" && addr ? addr.port : 0;
+			s.close(() => resolve(port));
+		});
+		s.on("error", reject);
+	});
+}
+
+function canConnect(port: number, host: string): Promise<boolean> {
+	return new Promise((resolve) => {
+		const sock = createConnection(port, host);
+		sock.setTimeout(800);
+		sock.on("connect", () => { sock.destroy(); resolve(true); });
+		sock.on("error",   () => { sock.destroy(); resolve(false); });
+		sock.on("timeout", () => { sock.destroy(); resolve(false); });
+	});
+}
+
+// Probe both IPv4 (127.0.0.1) and IPv6 (::1) — Vite binds to ::1 by default.
+async function waitForPort(port: number, timeoutMs = 30_000): Promise<boolean> {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		const [v4, v6] = await Promise.all([
+			canConnect(port, "127.0.0.1"),
+			canConnect(port, "::1"),
+		]);
+		if (v4 || v6) return true;
+		await new Promise((r) => setTimeout(r, 400));
+	}
+	return false;
+}
+
+type PM = "npm" | "pnpm" | "yarn";
+
+function detectPM(dir: string): PM {
+	if (existsSync(path.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+	if (existsSync(path.join(dir, "yarn.lock"))) return "yarn";
+	return "npm";
+}
+
+interface Cmd {
+	bin: string;
+	args: string[];
+	isVite: boolean;
+}
+
+function detectCmd(dir: string, pm: PM): Cmd | null {
+	const pkgPath = path.join(dir, "package.json");
+	if (!existsSync(pkgPath)) return null;
+
+	const pkg = JSON.parse(readFileSync(pkgPath, "utf-8")) as {
+		scripts?: Record<string, string>;
+		main?: string;
+		dependencies?: Record<string, string>;
+		devDependencies?: Record<string, string>;
+	};
+	const scripts = pkg.scripts ?? {};
+	const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+	const hasVite = Object.keys(allDeps).some((k) => k === "vite" || k.includes("vite"));
+
+	const run = (script: string, extraArgs: string[] = []): Cmd => ({
+		bin: pm,
+		args: ["run", script, ...(extraArgs.length ? ["--", ...extraArgs] : [])],
+		isVite: hasVite,
+	});
+
+	// Priority: start > preview (built) > dev > node main
+	if (scripts.start) return run("start");
+	if (scripts.preview && existsSync(path.join(dir, "dist"))) return run("preview");
+	if (scripts.dev) return run("dev");
+	if (pkg.main) return { bin: "node", args: [pkg.main], isVite: false };
+	return null;
+}
+
+function needsInstall(dir: string): boolean {
+	return !existsSync(path.join(dir, "node_modules"));
+}
+
+function runInstall(dir: string, pm: PM): Promise<void> {
+	return new Promise((resolve, reject) => {
+		const child = spawn(pm, ["install"], { cwd: dir, stdio: "pipe" });
+		child.on("exit", (code) => (code === 0 ? resolve() : reject(new Error(`${pm} install failed (exit ${code})`))));
+		child.on("error", reject);
+	});
+}
+
+// ── public API ───────────────────────────────────────────────────────────────
+
+export function getStatus(relPath: string): { status: AppStatus; port?: number; error?: string; logs: string[] } {
+	const app = apps.get(relPath);
+	if (!app) return { status: "stopped", logs: [] };
+	return { status: app.status, port: app.port || undefined, error: app.error, logs: app.logs };
+}
+
+export async function startApp(relPath: string, absPath: string): Promise<{ port: number }> {
+	const existing = apps.get(relPath);
+	if (existing && existing.status !== "stopped" && existing.status !== "error") {
+		return { port: existing.port };
+	}
+
+	const port = await findFreePort();
+	const pm = detectPM(absPath);
+	const cmd = detectCmd(absPath, pm);
+	if (!cmd) throw new Error("No runnable script found in package.json (need start, preview, or dev)");
+
+	const entry: RunningApp = { port, process: null, status: "installing", logs: [] };
+	apps.set(relPath, entry);
+
+	const pushLog = (line: string) => {
+		entry.logs.push(line);
+		if (entry.logs.length > 200) entry.logs.shift();
+	};
+
+	// Install if needed
+	if (needsInstall(absPath)) {
+		try {
+			pushLog(`[wiki-viewer] Running ${pm} install…`);
+			await runInstall(absPath, pm);
+		} catch (e) {
+			entry.status = "error";
+			entry.error = String(e);
+			return { port };
+		}
+	}
+
+	entry.status = "starting";
+	pushLog(`[wiki-viewer] Starting on port ${port}: ${cmd.bin} ${cmd.args.join(" ")}`);
+
+	const portArgs = cmd.isVite ? ["--port", String(port)] : [];
+	const child = spawn(cmd.bin, [...cmd.args, ...portArgs], {
+		cwd: absPath,
+		stdio: "pipe",
+		env: {
+			...process.env,
+			PORT: String(port),
+			VITE_PORT: String(port),
+		},
+	});
+	entry.process = child;
+
+	const handleOutput = (data: Buffer) => {
+		for (const line of data.toString().split("\n")) {
+			if (line.trim()) pushLog(line);
+		}
+	};
+	child.stdout?.on("data", handleOutput);
+	child.stderr?.on("data", handleOutput);
+
+	child.on("exit", (code) => {
+		const a = apps.get(relPath);
+		if (a?.process === child) {
+			a.status = code === 0 || code === null ? "stopped" : "error";
+			a.error = code ? `Process exited with code ${code}` : undefined;
+		}
+	});
+
+	// Wait for port in background
+	waitForPort(port).then((ok) => {
+		const a = apps.get(relPath);
+		if (a?.process === child) {
+			a.status = ok ? "running" : "error";
+			if (!ok) a.error = "Port never became reachable (30 s timeout)";
+		}
+	});
+
+	return { port };
+}
+
+export function stopApp(relPath: string): void {
+	const app = apps.get(relPath);
+	if (!app?.process) return;
+	try {
+		app.process.kill("SIGTERM");
+	} catch {}
+	app.status = "stopped";
+}
+
+export function listApps(): Array<{ relPath: string; status: AppStatus; port?: number }> {
+	return [...apps.entries()].map(([relPath, a]) => ({
+		relPath,
+		status: a.status,
+		port: a.port || undefined,
+	}));
+}
+
+/**
+ * Given URL path segments, find the longest prefix that matches a running app.
+ * e.g. ["apps", "roadmap-server", "api", "specs"] → { relPath: "apps/roadmap-server", port, rest: "/api/specs" }
+ */
+export function resolveByPrefix(
+	segments: string[],
+): { relPath: string; port: number; rest: string } | null {
+	for (let i = segments.length; i > 0; i--) {
+		const relPath = segments.slice(0, i).join("/");
+		const app = apps.get(relPath);
+		if (app && app.status === "running" && app.port) {
+			const rest = "/" + segments.slice(i).join("/");
+			return { relPath, port: app.port, rest };
+		}
+	}
+	return null;
+}

package/.next/standalone/src/lib/cabinets/tree.ts

@@ -0,0 +1,75 @@
+import type { TreeNode } from "@/types";
+
+function pathMatchesNode(targetPath: string, nodePath: string): boolean {
+	return targetPath === nodePath || targetPath.startsWith(`${nodePath}/`);
+}
+
+export function findRootCabinetNode(nodes: TreeNode[]): TreeNode | null {
+	const root = nodes[0];
+	return root?.type === "cabinet" && root.path === "." ? root : null;
+}
+
+export function findNodeByPath(
+	nodes: TreeNode[],
+	path: string,
+): TreeNode | null {
+	for (const node of nodes) {
+		if (node.path === path) return node;
+		if (node.children) {
+			const found = findNodeByPath(node.children, path);
+			if (found) return found;
+		}
+	}
+
+	return null;
+}
+
+export function findDeepestCabinetNode(
+	nodes: TreeNode[],
+	targetPath: string,
+): TreeNode | null {
+	let match: TreeNode | null = null;
+
+	for (const node of nodes) {
+		if (!pathMatchesNode(targetPath, node.path)) continue;
+
+		if (node.type === "cabinet") {
+			match = node;
+		}
+
+		if (node.children) {
+			const childMatch = findDeepestCabinetNode(node.children, targetPath);
+			if (childMatch) {
+				match = childMatch;
+			}
+		}
+	}
+
+	return match;
+}
+
+export function findParentCabinetNode(
+	nodes: TreeNode[],
+	cabinetPath: string,
+	cabinetAncestor: TreeNode | null = null,
+): TreeNode | null {
+	for (const node of nodes) {
+		const nextCabinetAncestor =
+			node.type === "cabinet" ? node : cabinetAncestor;
+
+		if (node.path === cabinetPath) {
+			return node.type === "cabinet" ? cabinetAncestor : null;
+		}
+
+		if (node.children) {
+			const found = findParentCabinetNode(
+				node.children,
+				cabinetPath,
+				nextCabinetAncestor,
+			);
+			if (found) return found;
+		}
+	}
+
+	return null;
+}

package/.next/standalone/src/lib/config.ts

@@ -0,0 +1,32 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+interface WikiViewerConfig {
+	pinnedPaths?: string[];
+	lastOpenedPath?: string;
+}
+
+function configPath() {
+	return path.join(os.homedir(), ".wiki-viewer", "config.json");
+}
+
+async function ensureDir() {
+	await mkdir(path.join(os.homedir(), ".wiki-viewer"), { recursive: true });
+}
+
+export async function readConfig(): Promise<WikiViewerConfig> {
+	try {
+		const raw = await readFile(configPath(), "utf8");
+		return JSON.parse(raw) as WikiViewerConfig;
+	} catch {
+		return {};
+	}
+}
+
+export async function writeConfig(patch: Partial<WikiViewerConfig>): Promise<void> {
+	await ensureDir();
+	const existing = await readConfig();
+	const next = { ...existing, ...patch };
+	await writeFile(configPath(), JSON.stringify(next, null, 2), "utf8");
+}

package/.next/standalone/src/lib/embeds/detect.ts

@@ -0,0 +1,142 @@
+export type EmbedProvider =
+	| "youtube"
+	| "vimeo"
+	| "loom"
+	| "twitter"
+	| "facebook"
+	| "instagram"
+	| "tiktok"
+	| "spotify"
+	| "video"
+	| "iframe";
+
+export interface DetectedEmbed {
+	provider: EmbedProvider;
+	embedUrl: string;
+	originalUrl: string;
+	/** Aspect ratio as width/height, e.g. 16/9 = 1.777… */
+	aspectRatio?: number;
+}
+
+const YT_ID =
+	/(?:youtube\.com\/(?:watch\?v=|shorts\/|embed\/|v\/)|youtu\.be\/)([A-Za-z0-9_-]{6,})/;
+const VIMEO_ID = /vimeo\.com\/(?:video\/)?(\d+)/;
+const LOOM_ID = /loom\.com\/share\/([A-Za-z0-9]+)/;
+const TWITTER = /^https?:\/\/(?:twitter\.com|x\.com)\/[^/]+\/status\/(\d+)/;
+const FACEBOOK = /^https?:\/\/(?:www\.)?facebook\.com\/.+/;
+const INSTAGRAM =
+	/^https?:\/\/(?:www\.)?instagram\.com\/(?:p|reel|tv)\/([^/?#]+)/;
+const TIKTOK = /^https?:\/\/(?:www\.)?tiktok\.com\/@[^/]+\/video\/(\d+)/;
+const SPOTIFY =
+	/^https?:\/\/open\.spotify\.com\/(track|album|playlist|episode|show)\/([A-Za-z0-9]+)/;
+const VIDEO_FILE = /\.(mp4|webm|ogg|mov|m4v)(\?|$)/i;
+
+export function detectEmbed(raw: string): DetectedEmbed | null {
+	const url = raw.trim();
+	if (!url) return null;
+
+	const yt = url.match(YT_ID);
+	if (yt) {
+		return {
+			provider: "youtube",
+			embedUrl: `https://www.youtube.com/embed/${yt[1]}`,
+			originalUrl: url,
+			aspectRatio: 16 / 9,
+		};
+	}
+
+	const vi = url.match(VIMEO_ID);
+	if (vi) {
+		return {
+			provider: "vimeo",
+			embedUrl: `https://player.vimeo.com/video/${vi[1]}`,
+			originalUrl: url,
+			aspectRatio: 16 / 9,
+		};
+	}
+
+	const lo = url.match(LOOM_ID);
+	if (lo) {
+		return {
+			provider: "loom",
+			embedUrl: `https://www.loom.com/embed/${lo[1]}`,
+			originalUrl: url,
+			aspectRatio: 16 / 9,
+		};
+	}
+
+	if (TWITTER.test(url)) {
+		return { provider: "twitter", embedUrl: url, originalUrl: url };
+	}
+
+	if (INSTAGRAM.test(url)) {
+		return {
+			provider: "instagram",
+			embedUrl: url.replace(/\/?(\?.*)?$/, "/embed"),
+			originalUrl: url,
+		};
+	}
+
+	const tt = url.match(TIKTOK);
+	if (tt) {
+		return {
+			provider: "tiktok",
+			embedUrl: `https://www.tiktok.com/embed/v2/${tt[1]}`,
+			originalUrl: url,
+			aspectRatio: 9 / 16,
+		};
+	}
+
+	const sp = url.match(SPOTIFY);
+	if (sp) {
+		return {
+			provider: "spotify",
+			embedUrl: `https://open.spotify.com/embed/${sp[1]}/${sp[2]}`,
+			originalUrl: url,
+		};
+	}
+
+	if (FACEBOOK.test(url)) {
+		return {
+			provider: "facebook",
+			embedUrl: `https://www.facebook.com/plugins/post.php?href=${encodeURIComponent(url)}&show_text=true`,
+			originalUrl: url,
+		};
+	}
+
+	if (VIDEO_FILE.test(url) || url.startsWith("/api/assets/")) {
+		return { provider: "video", embedUrl: url, originalUrl: url };
+	}
+
+	// Fallback: any http(s) URL can be embedded as a generic iframe.
+	if (/^https?:\/\//.test(url)) {
+		return { provider: "iframe", embedUrl: url, originalUrl: url };
+	}
+
+	return null;
+}
+
+export function providerLabel(p: EmbedProvider): string {
+	switch (p) {
+		case "youtube":
+			return "YouTube";
+		case "vimeo":
+			return "Vimeo";
+		case "loom":
+			return "Loom";
+		case "twitter":
+			return "X / Twitter";
+		case "facebook":
+			return "Facebook";
+		case "instagram":
+			return "Instagram";
+		case "tiktok":
+			return "TikTok";
+		case "spotify":
+			return "Spotify";
+		case "video":
+			return "Video file";
+		case "iframe":
+			return "Web page";
+	}
+}