@vivipilot/cli 0.1.0

package/src/render.ts

@@ -0,0 +1,424 @@
+import { spawn, type ChildProcess } from "node:child_process";
+import { createServer, type Server } from "node:http";
+import { readFile, writeFile, access, stat, mkdir } from "node:fs/promises";
+import { constants, openSync, writeSync, closeSync } from "node:fs";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+import type { CliConfig, Env } from "./config.js";
+import { CliError } from "./errors.js";
+import { resolveHeadlessBrowser, headlessBrowserArgs, BrowserNotFoundError } from "./browser.js";
+import { verifyManifestFile, checkManifestRevocationOnline, assertNotRevoked, checkRenderEntitlement, type RenderEntitlementRequest } from "./manifest.js";
+
+export type RenderOptions = {
+	manifestPath: string;
+	outPath: string;
+	format?: "mp4" | "webm" | "gif" | "mov";
+	width?: number;
+	height?: number;
+	fps?: number;
+	scale?: number;
+	transparent?: boolean;
+	verifyOnly?: boolean;
+};
+
+type RenderResult = {
+	ok: boolean;
+	outPath: string;
+	size: number;
+	manifestId: string;
+};
+
+const DEFAULT_RENDER_URL = "http://localhost:4001/headless-render";
+const DEFAULT_TIMEOUT_MS = 300_000;
+
+function startCallbackServer(outPath: string): Promise<{ server: Server; port: number }> {
+	return new Promise((resolve, reject) => {
+		let renderedBlob: Buffer | null = null;
+		let renderError: string | null = null;
+
+		const server = createServer(async (req, res) => {
+			res.setHeader("Access-Control-Allow-Origin", "*");
+			res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+			res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+
+			if (req.method === "OPTIONS") {
+				res.writeHead(204);
+				res.end();
+				return;
+			}
+
+			const url = new URL(req.url ?? "/", `http://localhost`);
+
+			if (url.pathname === "/manifest.json" && req.method === "GET") {
+				try {
+					const manifestJson = await readFile(outPath.replace(/\.mp4$|\.webm$|\.gif$|\.mov$/, ".vivi.json"), "utf8");
+					res.writeHead(200, { "content-type": "application/json" });
+					res.end(manifestJson);
+				} catch {
+					res.writeHead(404);
+					res.end("Manifest not found");
+				}
+				return;
+			}
+
+			if (url.pathname === "/result" && req.method === "POST") {
+				const chunks: Buffer[] = [];
+				req.on("data", (chunk: Buffer) => chunks.push(chunk));
+				req.on("end", async () => {
+					renderedBlob = Buffer.concat(chunks);
+					try {
+						await writeFile(outPath, renderedBlob);
+						res.writeHead(200, { "content-type": "application/json" });
+						res.end(JSON.stringify({ ok: true, size: renderedBlob.length }));
+					} catch (err) {
+						res.writeHead(500, { "content-type": "application/json" });
+						res.end(JSON.stringify({ ok: false, error: err instanceof Error ? err.message : String(err) }));
+					}
+				});
+				return;
+			}
+
+			if (url.pathname === "/error" && req.method === "POST") {
+				const chunks: Buffer[] = [];
+				req.on("data", (chunk: Buffer) => chunks.push(chunk));
+				req.on("end", () => {
+					try {
+						const body = JSON.parse(Buffer.concat(chunks).toString());
+						renderError = body.message ?? "Unknown render error";
+					} catch {
+						renderError = Buffer.concat(chunks).toString() || "Unknown render error";
+					}
+					res.writeHead(200, { "content-type": "application/json" });
+					res.end(JSON.stringify({ ok: true }));
+				});
+				return;
+			}
+
+			if (url.pathname === "/status" && req.method === "GET") {
+				res.writeHead(200, { "content-type": "application/json" });
+				res.end(JSON.stringify({
+					done: renderedBlob !== null || renderError !== null,
+					error: renderError,
+					hasBlob: renderedBlob !== null,
+					blobSize: renderedBlob?.length ?? 0,
+				}));
+				return;
+			}
+
+			res.writeHead(404);
+			res.end("Not found");
+		});
+
+		server.on("error", reject);
+		server.listen(0, "127.0.0.1", () => {
+			const addr = server.address();
+			if (!addr || typeof addr === "string") {
+				reject(new Error("Failed to bind callback server"));
+				return;
+			}
+			resolve({ server, port: addr.port });
+		});
+	});
+}
+
+async function waitForResult(port: number, timeoutMs: number): Promise<{ size: number; error: string | null }> {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		try {
+			const response = await fetch(`http://127.0.0.1:${port}/status`);
+			const status = await response.json() as { done: boolean; error: string | null; hasBlob: boolean; blobSize: number };
+			if (status.done) {
+				if (status.error) return { size: 0, error: status.error };
+				return { size: status.blobSize, error: null };
+			}
+		} catch { /* keep polling */ }
+		await new Promise(r => setTimeout(r, 1000));
+	}
+	return { size: 0, error: `Render timed out after ${timeoutMs / 1000}s` };
+}
+
+export async function renderManifest(
+	options: RenderOptions,
+	config: CliConfig,
+	env: Env = process.env,
+): Promise<RenderResult> {
+	const { manifestPath, outPath } = options;
+
+	// 1. Verify manifest signature
+	const verification = await verifyManifestFile(manifestPath, config, env);
+	if (!verification.ok) {
+		throw new CliError(`Manifest verification failed: ${verification.message}`, 1);
+	}
+
+	// 2. Online revocation check
+	const revocation = await checkManifestRevocationOnline(verification.manifest, config, env);
+	assertNotRevoked(revocation);
+
+	// 3. Entitlement check
+	const entitlementRequest: RenderEntitlementRequest = {
+		...(options.format ? { format: options.format } : {}),
+		...(options.width ? { width: options.width } : {}),
+		...(options.height ? { height: options.height } : {}),
+	};
+	const entitlement = checkRenderEntitlement(verification.manifest, entitlementRequest);
+	if (!entitlement.ok) throw new CliError(entitlement.message, 1);
+
+	if (options.verifyOnly) {
+		return { ok: true, outPath, size: 0, manifestId: verification.manifest.manifestId };
+	}
+
+	// 4. Resolve headless browser
+	let browser: { executablePath: string; source: string };
+	try {
+		browser = await resolveHeadlessBrowser(env);
+	} catch (err) {
+		if (err instanceof BrowserNotFoundError) {
+			throw new CliError(err.message, 1);
+		}
+		throw err;
+	}
+
+	// 5. Read manifest JSON
+	const manifestJson = await readFile(manifestPath, "utf8");
+	const manifest = JSON.parse(manifestJson) as any;
+	const canvas = manifest.render.canvas;
+
+	// 5.5. Cache external assets locally
+	let cacheDir = "";
+	if (manifest.render.assets && Array.isArray(manifest.render.assets)) {
+		try {
+			cacheDir = await cacheAssets(manifest.render.assets);
+		} catch (err) {
+			throw new CliError(`Failed to cache assets: ${err instanceof Error ? err.message : String(err)}`, 1);
+		}
+	}
+
+	// 6. Start callback server (serves manifest + receives rendered blob)
+	// We need a temp path for the manifest that the server can serve.
+	// Instead of writing to a temp file, we'll serve the manifest directly.
+	const { server } = await startCallbackServer(outPath);
+
+	// Patch the server to serve the manifest from memory instead of from outPath
+	// Actually, let's use a simpler approach: override the /manifest.json handler
+	// by writing the manifest to a known temp location.
+	// For now, the server reads from outPath.replace(ext, ".vivi.json") which
+	// isn't what we want. Let me fix this properly.
+
+	// Actually, let's just re-create the server with the manifest in memory.
+	server.close();
+
+	let renderError: string | null = null;
+	let hasBlob = false;
+	let blobSize = 0;
+
+	const manifestServer = createServer((req, res) => {
+		res.setHeader("Access-Control-Allow-Origin", "*");
+		res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+		res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+
+		if (req.method === "OPTIONS") {
+			res.writeHead(204);
+			res.end();
+			return;
+		}
+
+		const url = new URL(req.url ?? "/", `http://localhost`);
+
+		if (cacheDir && url.pathname.startsWith("/assets/") && req.method === "GET") {
+			const sha256 = url.pathname.slice(8);
+			const cachedPath = join(cacheDir, sha256);
+			readFile(cachedPath)
+				.then((buffer) => {
+					const asset = manifest.render.assets?.find((a: any) => a.sha256 === sha256);
+					res.writeHead(200, { "content-type": asset?.mimeType || "application/octet-stream" });
+					res.end(buffer);
+				})
+				.catch(() => {
+					res.writeHead(404);
+					res.end("Asset not found");
+				});
+			return;
+		}
+
+		if (url.pathname === "/manifest.json" && req.method === "GET") {
+			const manifestObj = { ...manifest };
+			if (manifestObj.render?.assets) {
+				manifestObj.render.assets = manifestObj.render.assets.map((asset: any) => ({
+					...asset,
+					url: `http://127.0.0.1:${serverPort}/assets/${asset.sha256}`,
+				}));
+			}
+			res.writeHead(200, { "content-type": "application/json" });
+			res.end(JSON.stringify(manifestObj));
+			return;
+		}
+
+		if (url.pathname === "/result" && req.method === "POST") {
+			const chunks: Buffer[] = [];
+			req.on("data", (chunk: Buffer) => chunks.push(chunk));
+			req.on("end", async () => {
+				const blob = Buffer.concat(chunks);
+				try {
+					await writeFile(outPath, blob);
+					hasBlob = true;
+					blobSize = blob.length;
+					res.writeHead(200, { "content-type": "application/json" });
+					res.end(JSON.stringify({ ok: true, size: blob.length }));
+				} catch (err) {
+					renderError = err instanceof Error ? err.message : String(err);
+					res.writeHead(500, { "content-type": "application/json" });
+					res.end(JSON.stringify({ ok: false, error: renderError }));
+				}
+			});
+			return;
+		}
+
+		if (url.pathname === "/error" && req.method === "POST") {
+			const chunks: Buffer[] = [];
+			req.on("data", (chunk: Buffer) => chunks.push(chunk));
+			req.on("end", () => {
+				let errorMsg = "Unknown render error";
+				try {
+					const body = JSON.parse(Buffer.concat(chunks).toString());
+					errorMsg = body.message ?? errorMsg;
+				} catch {
+					errorMsg = Buffer.concat(chunks).toString() || errorMsg;
+				}
+				renderError = errorMsg;
+				res.writeHead(200, { "content-type": "application/json" });
+				res.end(JSON.stringify({ ok: true, error: errorMsg }));
+			});
+			return;
+		}
+
+		if (url.pathname === "/status" && req.method === "GET") {
+			res.writeHead(200, { "content-type": "application/json" });
+			res.end(JSON.stringify({
+				done: hasBlob || renderError !== null,
+				error: renderError,
+				hasBlob,
+				blobSize,
+			}));
+			return;
+		}
+
+		res.writeHead(404);
+		res.end("Not found");
+	});
+
+	const serverPort = await new Promise<number>((resolve, reject) => {
+		manifestServer.on("error", reject);
+		manifestServer.listen(0, "127.0.0.1", () => {
+			const addr = manifestServer.address();
+			if (!addr || typeof addr === "string") {
+				reject(new Error("Failed to bind manifest server"));
+				return;
+			}
+			resolve(addr.port);
+		});
+	});
+
+	// 7. Build render URL — points at the host app's /headless-render page
+	const renderBaseUrl = env.VIVIPILOT_RENDER_URL ?? DEFAULT_RENDER_URL;
+	const params = new URLSearchParams({
+		manifest: `http://127.0.0.1:${serverPort}/manifest.json`,
+		format: options.format ?? "mp4",
+		headless: "true",
+		callback: `http://127.0.0.1:${serverPort}/result`,
+	});
+	if (options.scale) params.set("scale", String(options.scale));
+	if (options.transparent) params.set("transparent", "true");
+	if (options.fps) params.set("fps", String(options.fps));
+
+	const fullRenderUrl = `${renderBaseUrl}?${params.toString()}`;
+
+	// 8. Spawn headless browser
+	const args = headlessBrowserArgs(fullRenderUrl, {
+		windowSize: { width: Math.max(canvas.width, 1280), height: Math.max(canvas.height, 720) },
+	});
+
+	const child: ChildProcess = spawn(browser.executablePath, args, {
+		stdio: ["ignore", "pipe", "pipe"],
+		env: { ...env, DISPLAY: env.DISPLAY ?? ":99" },
+	});
+
+	const chromeLogPath = join(process.cwd(), "host", "chrome_browser.log");
+	const chromeLogFd = openSync(chromeLogPath, "w");
+
+	let browserStderr = "";
+	let browserStdout = "";
+	child.stderr?.on("data", (data: Buffer) => {
+		browserStderr += data.toString();
+		try { writeSync(chromeLogFd, data); } catch {}
+	});
+	child.stdout?.on("data", (data: Buffer) => {
+		browserStdout += data.toString();
+		try { writeSync(chromeLogFd, data); } catch {}
+	});
+
+	// 9. Wait for the blob to arrive at /result, or timeout
+	const timeoutMs = parseInt(env.VIVIPILOT_RENDER_TIMEOUT_MS ?? String(DEFAULT_TIMEOUT_MS), 10);
+	const result = await waitForResult(serverPort, timeoutMs);
+
+	// 10. Clean up
+	child.kill("SIGTERM");
+	setTimeout(() => {
+		try { child.kill("SIGKILL"); } catch { /* already dead */ }
+	}, 5000);
+
+	manifestServer.close();
+	try { closeSync(chromeLogFd); } catch {}
+
+	if (result.error) {
+		throw new CliError(
+			`Render failed: ${result.error}\nBrowser stderr (last 2KB):\n${browserStderr.slice(-2000)}\nBrowser stdout (last 1KB):\n${browserStdout.slice(-1000)}`,
+			1,
+		);
+	}
+
+	// 11. Verify output file exists
+	try {
+		await access(outPath, constants.R_OK);
+		const stats = await stat(outPath);
+		return { ok: true, outPath, size: stats.size, manifestId: verification.manifest.manifestId };
+	} catch {
+		throw new CliError(`Render completed but output file not found at ${outPath}`, 1);
+	}
+}
+
+async function cacheAssets(assets: any[]): Promise<string> {
+	const cacheDir = join(
+		process.env.HOME || process.env.USERPROFILE || process.cwd(),
+		".cache",
+		"vivipilot",
+		"assets"
+	);
+	await mkdir(cacheDir, { recursive: true });
+
+	for (const asset of assets) {
+		if (!asset.sha256 || !asset.url) continue;
+		const cachedPath = join(cacheDir, asset.sha256);
+
+		try {
+			await access(cachedPath);
+			continue;
+		} catch {
+			// Asset not in cache, download it
+		}
+
+		const res = await fetch(asset.url);
+		if (!res.ok) {
+			throw new Error(`Failed to download asset ${asset.url}: HTTP ${res.status}`);
+		}
+		const buffer = Buffer.from(await res.arrayBuffer());
+
+		const hash = createHash("sha256").update(buffer).digest("hex");
+		if (hash !== asset.sha256) {
+			throw new Error(`Asset hash mismatch for ${asset.url}: expected ${asset.sha256}, got ${hash}`);
+		}
+
+		await writeFile(cachedPath, buffer);
+	}
+
+	return cacheDir;
+}

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022", "DOM"],
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "isolatedModules": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]
+}