blodemd 0.0.4 → 0.0.6

package/dev-server/tsconfig.json

@@ -0,0 +1,49 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "declaration": true,
+    "declarationMap": true,
+    "esModuleInterop": true,
+    "incremental": false,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "lib": [
+      "es2022",
+      "DOM",
+      "DOM.Iterable"
+    ],
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "moduleResolution": "Bundler",
+    "noEmit": true,
+    "noUncheckedIndexedAccess": true,
+    "paths": {
+      "@/*": [
+        "../docs/*"
+      ],
+      "@dev/*": [
+        "./*"
+      ]
+    },
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "strictNullChecks": true,
+    "target": "ES2022"
+  },
+  "exclude": [
+    "node_modules"
+  ],
+  "include": [
+    "**/*.ts",
+    "**/*.tsx",
+    "next-env.d.ts",
+    "next.config.js",
+    ".next/types/**/*.ts"
+  ]
+}

package/dist/cli.mjs

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { spawn, spawnSync } from "node:child_process";
 import fs, { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import path, { join } from "node:path";
 import { confirm, intro, isCancel, log, password, spinner } from "@clack/prompts";
@@ -7,6 +8,11 @@ import chalk from "chalk";
 import { Command } from "commander";
 import open from "open";
 import { homedir } from "node:os";
+import { once } from "node:events";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { fileURLToPath } from "node:url";
+import { createFsSource, loadSiteConfig } from "@repo/previewing";
+import { watch } from "chokidar";
 import { createServer } from "node:http";
 import { createHash, randomBytes } from "node:crypto";
 //#region src/constants.ts
@@ -283,6 +289,257 @@ const resolveTokenStatus = (token) => {
 	};
 };
 //#endregion
+//#region src/dev/resolve-root.ts
+const CONFIG_FILE$1 = "docs.json";
+const fileExists$2 = async (filePath) => {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+};
+const resolveDocsRoot$1 = async (dir) => {
+	if (dir) return path.resolve(process.cwd(), dir);
+	const candidates = [
+		process.cwd(),
+		path.join(process.cwd(), "docs"),
+		path.join(process.cwd(), "apps/docs")
+	];
+	for (const candidate of candidates) if (await fileExists$2(path.join(candidate, CONFIG_FILE$1))) return candidate;
+	return process.cwd();
+};
+const validateDocsRoot = async (root) => {
+	const result = await loadSiteConfig(createFsSource(root));
+	if (!result.ok) throw new CliError(result.errors.join("\n"), EXIT_CODES.VALIDATION, `Make sure ${CONFIG_FILE$1} exists and is valid JSON.`);
+	return result;
+};
+//#endregion
+//#region src/dev/watcher.ts
+const INVALIDATE_ENDPOINT = "/blodemd-dev/invalidate";
+const WATCH_DEBOUNCE_MS = 100;
+const normalizeRelativePath$1 = (root, filePath) => path.relative(root, filePath).split(path.sep).join("/");
+const isDirectoryEvent = (event) => event === "addDir" || event === "unlinkDir";
+const createDevWatcher = ({ port, root }) => {
+	const watcher = watch(root, {
+		ignoreInitial: true,
+		ignored: [
+			"**/.git/**",
+			"**/.next/**",
+			"**/dist/**",
+			"**/node_modules/**"
+		]
+	});
+	let flushTimer = null;
+	let pendingKind = "content";
+	const pendingPaths = /* @__PURE__ */ new Set();
+	const flush = async () => {
+		flushTimer = null;
+		const paths = [...pendingPaths];
+		const kind = pendingKind;
+		pendingPaths.clear();
+		pendingKind = "content";
+		if (!paths.length) return;
+		try {
+			const response = await fetch(`http://127.0.0.1:${port}${INVALIDATE_ENDPOINT}`, {
+				body: JSON.stringify({
+					kind,
+					paths
+				}),
+				headers: { "Content-Type": "application/json" },
+				method: "POST"
+			});
+			if (!response.ok) throw new Error(`HTTP ${response.status}`);
+		} catch (error) {
+			log.error(`Failed to invalidate preview cache: ${error instanceof Error ? error.message : "unknown error"}`);
+		}
+	};
+	watcher.on("all", (event, changedPath) => {
+		if (isDirectoryEvent(event)) return;
+		const relativePath = normalizeRelativePath$1(root, changedPath);
+		pendingPaths.add(relativePath);
+		if (path.basename(changedPath) === "docs.json") pendingKind = "config";
+		if (flushTimer) clearTimeout(flushTimer);
+		flushTimer = setTimeout(() => {
+			flush();
+		}, WATCH_DEBOUNCE_MS);
+	});
+	return { async close() {
+		if (flushTimer) {
+			clearTimeout(flushTimer);
+			await flush();
+		}
+		await watcher.close();
+	} };
+};
+//#endregion
+//#region src/dev/command.ts
+const DEV_READY_ENDPOINT = "/blodemd-dev/version";
+const DEV_READY_TIMEOUT_MS = 45e3;
+const parsePositiveInteger$1 = (value, label) => {
+	const parsed = Number.parseInt(value, 10);
+	if (!Number.isInteger(parsed) || parsed <= 0) throw new CliError(`${label} must be a positive integer.`, EXIT_CODES.VALIDATION);
+	return parsed;
+};
+const fileExists$1 = async (filePath) => {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+};
+/**
+* Derive the CLI npm package root from the running script path.
+* The CLI entry point is at `<pkg-root>/dist/cli.mjs`.
+*/
+const resolveCliPackageRoot = (cliFilePath) => path.dirname(path.dirname(cliFilePath));
+/**
+* Check if a shipped dev-server exists alongside the CLI (npm-installed mode).
+* Verifies both the dev-server directory AND that `next` is resolvable
+* (it's a dependency when npm-installed, but not in the monorepo).
+*/
+const findStandaloneDevServer = async (cliPackageRoot) => {
+	const devServerDir = path.join(cliPackageRoot, "dev-server");
+	if (!await fileExists$1(path.join(devServerDir, "next.config.js"))) return null;
+	try {
+		createRequire(path.join(cliPackageRoot, "package.json")).resolve("next/package.json");
+	} catch {
+		return null;
+	}
+	return {
+		devServerDir,
+		mode: "standalone",
+		packagesDir: path.join(cliPackageRoot, "packages")
+	};
+};
+/**
+* Resolve the `next` CLI binary from the blodemd package's own dependencies.
+*/
+const resolveNextBin = (cliPackageRoot) => {
+	const nextPkgPath = createRequire(path.join(cliPackageRoot, "package.json")).resolve("next/package.json");
+	return path.join(path.dirname(nextPkgPath), "dist", "bin", "next");
+};
+const findMonorepoRoot = async (start) => {
+	let current = start;
+	while (true) {
+		const packageJsonPath = path.join(current, "package.json");
+		if (await fileExists$1(packageJsonPath)) {
+			const raw = await fs.readFile(packageJsonPath, "utf8");
+			const workspaces = JSON.parse(raw).workspaces ?? [];
+			if (workspaces.includes("apps/*") && workspaces.includes("packages/*")) return current;
+		}
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	throw new CliError("Could not locate the blodemd dev server.", EXIT_CODES.ERROR, "Make sure blodemd is installed correctly (npm i blodemd).");
+};
+const resolveDevServer = async (cliFilePath) => {
+	const standalone = await findStandaloneDevServer(resolveCliPackageRoot(cliFilePath));
+	if (standalone) return standalone;
+	return {
+		mode: "monorepo",
+		repoRoot: await findMonorepoRoot(path.dirname(cliFilePath))
+	};
+};
+const spawnDevServer = (server, { root, port }) => {
+	if (server.mode === "standalone") {
+		const nextBin = resolveNextBin(path.dirname(server.devServerDir));
+		return spawn(process.execPath, [nextBin, "dev"], {
+			cwd: server.devServerDir,
+			env: {
+				...process.env,
+				BLODEMD_PACKAGES_DIR: server.packagesDir,
+				DOCS_ROOT: root,
+				NODE_PATH: [server.packagesDir, process.env.NODE_PATH].filter(Boolean).join(path.delimiter),
+				PORT: String(port)
+			},
+			stdio: "inherit"
+		});
+	}
+	return spawn(process.platform === "win32" ? "npm.cmd" : "npm", [
+		"run",
+		"dev",
+		"--workspace=dev-server"
+	], {
+		cwd: server.repoRoot,
+		env: {
+			...process.env,
+			DOCS_ROOT: root,
+			PORT: String(port)
+		},
+		stdio: "inherit"
+	});
+};
+const waitForServer = async ({ child, port }) => {
+	const url = `http://localhost:${port}${DEV_READY_ENDPOINT}`;
+	const startedAt = Date.now();
+	while (Date.now() - startedAt < DEV_READY_TIMEOUT_MS) {
+		if (child.exitCode !== null) throw new CliError("The local dev server exited before it became ready.", EXIT_CODES.ERROR);
+		try {
+			if ((await fetch(url, {
+				cache: "no-store",
+				headers: { accept: "application/json" }
+			})).ok) return;
+		} catch {}
+		await setTimeout$1(500);
+	}
+	throw new CliError("Timed out waiting for the local dev server to start.", EXIT_CODES.ERROR);
+};
+const devCommand = async ({ dir, openBrowser, port: portValue }) => {
+	intro(chalk.bold("blodemd dev"));
+	try {
+		const port = parsePositiveInteger$1(portValue, "Port");
+		const root = await resolveDocsRoot$1(dir);
+		await validateDocsRoot(root);
+		const server = await resolveDevServer(fileURLToPath(import.meta.url));
+		const localUrl = `http://localhost:${port}`;
+		log.info(`Docs root: ${chalk.cyan(root)}`);
+		const child = spawnDevServer(server, {
+			port,
+			root
+		});
+		let watcher = null;
+		let shuttingDown = false;
+		const closeAll = async () => {
+			if (shuttingDown) return;
+			shuttingDown = true;
+			if (watcher) {
+				await watcher.close();
+				watcher = null;
+			}
+			if (child.exitCode === null && !child.killed) child.kill("SIGTERM");
+		};
+		process.once("SIGINT", closeAll);
+		process.once("SIGTERM", closeAll);
+		try {
+			await waitForServer({
+				child,
+				port
+			});
+			watcher = await createDevWatcher({
+				port,
+				root
+			});
+			log.success(`Dev server running at ${chalk.cyan(localUrl)}`);
+			if (openBrowser) await open(localUrl);
+			const [code, signal] = await once(child, "exit");
+			if (shuttingDown || signal === "SIGINT" || signal === "SIGTERM") return;
+			if (code !== 0) throw new CliError(`The local dev server exited with code ${code ?? "unknown"}.`, EXIT_CODES.ERROR);
+		} finally {
+			await closeAll();
+			process.removeListener("SIGINT", closeAll);
+			process.removeListener("SIGTERM", closeAll);
+		}
+	} catch (error) {
+		const cliError = toCliError(error);
+		log.error(cliError.message);
+		if (cliError.hint) log.info(cliError.hint);
+		process.exitCode = cliError.exitCode;
+	}
+};
+//#endregion
 //#region src/oauth-callback.ts
 const SUCCESS_HTML = "<!doctype html><html><head><meta charset=\"utf-8\"/><title>Blode.md CLI</title></head><body><h2>Logged in! You can close this tab.</h2></body></html>";
 const escapeHtml = (text) => text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
@@ -294,6 +551,7 @@ const waitForOAuthCode = (options) => {
 	if (!Number.isInteger(port) || port <= 0) return Promise.reject(new CliError("OAuth redirect URL requires an explicit port", EXIT_CODES.ERROR));
 	return new Promise((resolve, reject) => {
 		let settled = false;
+		const sockets = /* @__PURE__ */ new Set();
 		const settle = (ok, value) => {
 			if (settled) return;
 			settled = true;
@@ -302,6 +560,7 @@ const waitForOAuthCode = (options) => {
 				if (ok) resolve(value);
 				else reject(value);
 			});
+			for (const socket of sockets) socket.destroy();
 		};
 		const httpServer = createServer((request, response) => {
 			if (!request.url) {
@@ -341,6 +600,10 @@ const waitForOAuthCode = (options) => {
 			response.end(SUCCESS_HTML);
 			settle(true, code);
 		});
+		httpServer.on("connection", (socket) => {
+			sockets.add(socket);
+			socket.once("close", () => sockets.delete(socket));
+		});
 		httpServer.on("error", (error) => {
 			settle(false, new CliError(`Failed to start callback server on ${host}:${port}: ${error.message}`, EXIT_CODES.ERROR));
 		});
@@ -506,21 +769,39 @@ const autoCreateProject = async (project, apiUrl, headers) => {
 	log.info(`API key for CI: ${chalk.dim(createResult.token)}`);
 	return true;
 };
+const MAX_BATCH_BYTES = 4 * 1024 * 1024;
 const uploadFiles = async (files, root, apiPath, deploymentId, headers, s) => {
 	s.start(`Uploading ${files.length} files`);
-	for (const [index, filePath] of files.entries()) {
-		const relativePath = normalizeRelativePath(root, filePath);
-		const content = await fs.readFile(filePath);
-		await requestJson(apiPath(`/${deploymentId}/files`), {
-			body: JSON.stringify({
-				contentBase64: content.toString("base64"),
-				contentType: getContentType(filePath),
-				path: relativePath
-			}),
+	const items = await Promise.all(files.map(async (filePath) => {
+		return {
+			contentBase64: (await fs.readFile(filePath)).toString("base64"),
+			contentType: getContentType(filePath),
+			path: normalizeRelativePath(root, filePath)
+		};
+	}));
+	const batches = [];
+	let current = [];
+	let currentBytes = 0;
+	for (const item of items) {
+		const itemBytes = item.contentBase64.length + item.path.length + 64;
+		if (current.length > 0 && currentBytes + itemBytes > MAX_BATCH_BYTES) {
+			batches.push(current);
+			current = [];
+			currentBytes = 0;
+		}
+		current.push(item);
+		currentBytes += itemBytes;
+	}
+	if (current.length > 0) batches.push(current);
+	let uploaded = 0;
+	for (const batch of batches) {
+		await requestJson(apiPath(`/${deploymentId}/files/batch`), {
+			body: JSON.stringify({ files: batch }),
 			headers,
 			method: "POST"
-		}, `Failed to upload ${relativePath}`);
-		s.message(`Uploading files (${index + 1}/${files.length})`);
+		}, "Failed to upload files");
+		uploaded += batch.length;
+		s.message(`Uploading files (${uploaded}/${files.length})`);
 	}
 	s.stop(`Uploaded ${chalk.cyan(String(files.length))} files`);
 };
@@ -624,14 +905,7 @@ program.command("whoami").description("Show current authentication").action(asyn
 		const email = resolved.user?.email ?? await fetchUserEmail(process.env["BLODEMD_API_URL"] ?? "https://api.blode.md", resolved.token);
 		if (email) log.info(`Logged in as ${chalk.cyan(email)}`);
 		else log.info("Logged in (could not fetch user details).");
-		if (resolved.expiresAt) {
-			if (status.expired) log.warn("Session has expired. Run \"blodemd login\" to re-authenticate.");
-			else if (status.expiresInSeconds !== null) {
-				const hours = Math.floor(status.expiresInSeconds / 3600);
-				const minutes = Math.floor(status.expiresInSeconds % 3600 / 60);
-				log.info(`Session expires in ${hours}h ${minutes}m`);
-			}
-		}
+		if (resolved.expiresAt && status.expired) log.warn("Session has expired. Run \"blodemd login\" to re-authenticate.");
 	} catch (error) {
 		reportCommandError("Whoami failed", error);
 	}
@@ -731,12 +1005,11 @@ program.command("push").description("Deploy docs").argument("[dir]", "docs direc
 		reportCommandError("Push failed", error);
 	}
 });
-program.command("dev").description("Start the docs dev server").action(() => {
-	intro(chalk.bold("blodemd dev"));
-	log.info(`Run ${chalk.cyan("npm run dev --filter=docs")} from the repo root.`);
-	log.info(`Then open ${chalk.cyan("http://localhost:3001")} to view the docs site.`);
-	log.info("Done");
-});
+program.command("dev").description("Start the local docs dev server").option("-p, --port <port>", "Port number", "3030").option("-d, --dir <dir>", "Docs directory").option("--no-open", "Don't open browser").action(async (options) => await devCommand({
+	dir: options.dir,
+	openBrowser: options.open ?? true,
+	port: options.port
+}));
 program.parse();
 //#endregion
 export {};