@vivipilot/cli 0.1.0 → 0.1.1

package/src/browser.test.ts

@@ -1,103 +0,0 @@
-import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
-import { headlessBrowserArgs, BrowserNotFoundError, resolveHeadlessBrowser } from "./browser.js";
-
-let mockNoBrowsers = false;
-
-vi.mock("node:fs/promises", async (importOriginal) => {
-  const original = await importOriginal<typeof import("node:fs/promises")>();
-  return {
-    ...original,
-    access: async (path: string, mode?: number) => {
-      if (mockNoBrowsers) {
-        throw new Error("Mocked: File not executable");
-      }
-      return original.access(path, mode);
-    },
-  };
-});
-
-describe("headlessBrowserArgs", () => {
-  it("includes headless flag and render URL", () => {
-    const args = headlessBrowserArgs("http://localhost:4001/headless-render");
-    expect(args).toContain("--headless=new");
-    expect(args).toContain("http://localhost:4001/headless-render");
-  });
-
-  it("includes GPU/WebGL enablement flags", () => {
-    const args = headlessBrowserArgs("http://example.com");
-    expect(args).toContain("--use-gl=angle");
-    expect(args).toContain("--use-angle=swiftshader");
-    expect(args).toContain("--enable-unsafe-swiftshader");
-    expect(args).toContain("--ignore-gpu-blocklist");
-  });
-
-  it("includes no-sandbox flags for CI", () => {
-    const args = headlessBrowserArgs("http://example.com");
-    expect(args).toContain("--no-sandbox");
-    expect(args).toContain("--disable-gpu-sandbox");
-    expect(args).toContain("--disable-dev-shm-usage");
-  });
-
-  it("sets window size from options", () => {
-    const args = headlessBrowserArgs("http://example.com", {
-      windowSize: { width: 1920, height: 1080 },
-    });
-    expect(args).toContain("--window-size=1920,1080");
-  });
-
-  it("defaults to 1920x1080", () => {
-    const args = headlessBrowserArgs("http://example.com");
-    expect(args).toContain("--window-size=1920,1080");
-  });
-
-  it("appends extra args", () => {
-    const args = headlessBrowserArgs("http://example.com", {
-      extraArgs: ["--remote-debugging-port=9222"],
-    });
-    expect(args).toContain("--remote-debugging-port=9222");
-  });
-
-  it("URL is the last argument", () => {
-    const url = "http://localhost:1234/render";
-    const args = headlessBrowserArgs(url);
-    expect(args[args.length - 1]).toBe(url);
-  });
-});
-
-describe("BrowserNotFoundError", () => {
-  it("is an Error subclass", () => {
-    const err = new BrowserNotFoundError("not found");
-    expect(err).toBeInstanceOf(Error);
-    expect(err.name).toBe("BrowserNotFoundError");
-    expect(err.message).toBe("not found");
-  });
-});
-
-describe("resolveHeadlessBrowser", () => {
-  beforeEach(() => {
-    mockNoBrowsers = false;
-  });
-
-  afterEach(() => {
-    mockNoBrowsers = false;
-  });
-
-  it("throws BrowserNotFoundError when no browser is available", async () => {
-    mockNoBrowsers = true;
-    const env: Record<string, string | undefined> = {
-      VIVIPILOT_HEADLESS_BROWSER: undefined,
-      PUPPETEER_EXECUTABLE_PATH: undefined,
-      HOME: "/nonexistent-home-path-for-testing",
-    };
-    await expect(resolveHeadlessBrowser(env)).rejects.toBeInstanceOf(BrowserNotFoundError);
-  });
-
-  it("uses VIVIPILOT_HEADLESS_BROWSER when set to an executable", async () => {
-    const env: Record<string, string | undefined> = {
-      VIVIPILOT_HEADLESS_BROWSER: "/bin/true",
-    };
-    const result = await resolveHeadlessBrowser(env);
-    expect(result.executablePath).toBe("/bin/true");
-    expect(result.source).toBe("env");
-  });
-});

package/src/browser.ts

@@ -1,174 +0,0 @@
-import { existsSync } from "node:fs";
-import { access, constants } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
-export type BrowserResolution = {
-	executablePath: string;
-	source: "env" | "chrome-headless-shell" | "system-chrome" | "system-chromium";
-};
-
-export class BrowserNotFoundError extends Error {
-	constructor(message: string) {
-		super(message);
-		this.name = "BrowserNotFoundError";
-	}
-}
-
-/**
- * Resolve a browser binary for headless rendering.
- *
- * Priority:
- * 1. `VIVIPILOT_HEADLESS_BROWSER` env var (explicit override)
- * 2. `chrome-headless-shell` in PATH or common install locations
- * 3. System Chrome / Chromium in common install locations
- *
- * Returns the path + source. Throws `BrowserNotFoundError` when no browser is found.
- */
-export async function resolveHeadlessBrowser(env: NodeJS.ProcessEnv = process.env): Promise<BrowserResolution> {
-	const envPath = env.VIVIPILOT_HEADLESS_BROWSER;
-	if (envPath && await isExecutable(envPath)) {
-		return { executablePath: envPath, source: "env" };
-	}
-
-	const shell = await findChromeHeadlessShell();
-	if (shell) return { executablePath: shell, source: "chrome-headless-shell" };
-
-	const chrome = await findSystemChrome();
-	if (chrome) return { executablePath: chrome, source: "system-chrome" };
-
-	const chromium = await findSystemChromium();
-	if (chromium) return { executablePath: chromium, source: "system-chromium" };
-
-	throw new BrowserNotFoundError(
-		"No headless browser found. Install chrome-headless-shell or Chrome/Chromium, or set VIVIPILOT_HEADLESS_BROWSER to the binary path.",
-	);
-}
-
-async function isExecutable(path: string): Promise<boolean> {
-	try {
-		await access(path, constants.X_OK);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-async function findChromeHeadlessShell(): Promise<string | null> {
-	const candidates = [
-		process.env.PUPPETEER_EXECUTABLE_PATH,
-		join(homedir(), ".cache", "puppeteer", "chrome-headless-shell"),
-		"/usr/bin/chrome-headless-shell",
-		"/usr/local/bin/chrome-headless-shell",
-		"/snap/bin/chrome-headless-shell",
-		join(homedir(), ".local", "share", "chrome-headless-shell", "chrome-headless-shell"),
-		"/opt/chrome-headless-shell/chrome-headless-shell",
-		// macOS
-		"/Applications/Google Chrome Headless Shell.app/Contents/MacOS/Google Chrome Headless Shell",
-		// Windows
-		join(homedir(), "AppData", "Local", "chrome-headless-shell", "chrome-headless-shell.exe"),
-	];
-
-	for (const candidate of candidates) {
-		if (!candidate) continue;
-		if (await isExecutable(candidate)) return candidate;
-		// Some install dirs contain a versioned subfolder
-		if (existsSync(candidate) && !candidate.endsWith("chrome-headless-shell") && !candidate.endsWith(".exe")) {
-			// Search for the binary inside versioned subdirs
-			const { readdirSync } = await import("node:fs");
-			try {
-				const entries = readdirSync(candidate, { withFileTypes: true });
-				for (const entry of entries) {
-					if (!entry.isDirectory()) continue;
-					const inner = join(candidate, entry.name, "chrome-headless-shell");
-					if (await isExecutable(inner)) return inner;
-					const innerExe = join(candidate, entry.name, "chrome-headless-shell.exe");
-					if (await isExecutable(innerExe)) return innerExe;
-				}
-			} catch { /* ignore */ }
-		}
-	}
-	return null;
-}
-
-async function findSystemChrome(): Promise<string | null> {
-	const candidates = [
-		"/usr/bin/google-chrome",
-		"/usr/bin/google-chrome-stable",
-		"/usr/bin/google-chrome-unstable",
-		"/usr/local/bin/google-chrome",
-		"/opt/google/chrome/chrome",
-		"/snap/bin/google-chrome",
-		// macOS
-		"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
-		// Windows
-		join(homedir(), "AppData", "Local", "Google", "Chrome", "Application", "chrome.exe"),
-		"C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
-		"C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
-	];
-
-	for (const candidate of candidates) {
-		if (await isExecutable(candidate)) return candidate;
-	}
-	return null;
-}
-
-async function findSystemChromium(): Promise<string | null> {
-	const candidates = [
-		"/usr/bin/chromium",
-		"/usr/bin/chromium-browser",
-		"/usr/local/bin/chromium",
-		"/snap/bin/chromium",
-		"/usr/bin/brave-browser",
-		"/usr/bin/brave",
-		"/Applications/Chromium.app/Contents/MacOS/Chromium",
-		join(homedir(), "AppData", "Local", "Chromium", "Application", "chromium.exe"),
-		"C:\\Program Files\\Chromium\\Application\\chromium.exe",
-	];
-
-	for (const candidate of candidates) {
-		if (await isExecutable(candidate)) return candidate;
-	}
-	return null;
-}
-
-/**
- * Build the Chrome/Chromium CLI flags for headless rendering with WebGL/WebGPU support.
- * These flags ensure the GPU is available (or SwiftShader fallback) so Pixi v8 can
- * initialise its renderer inside a headless browser.
- */
-export function headlessBrowserArgs(renderUrl: string, options?: {
-	windowSize?: { width: number; height: number };
-	extraArgs?: string[];
-}): string[] {
-	const width = options?.windowSize?.width ?? 1920;
-	const height = options?.windowSize?.height ?? 1080;
-
-	return [
-		"--headless=new",
-		"--no-sandbox",
-		"--disable-gpu-sandbox",
-		"--disable-dev-shm-usage",
-		"--disable-extensions",
-		"--disable-background-networking",
-		"--disable-sync",
-		"--disable-translate",
-		"--disable-default-apps",
-		"--disable-popup-blocking",
-		"--disable-component-update",
-		"--disable-metrics",
-		"--no-first-run",
-		"--mute-audio",
-		"--enable-logging=stderr",
-		"--log-level=0",
-		"--v=1",
-		`--window-size=${width},${height}`,
-		"--enable-features=Vulkan",
-		"--use-gl=angle",
-		"--use-angle=swiftshader",
-		"--enable-unsafe-swiftshader",
-		"--ignore-gpu-blocklist",
-		...(options?.extraArgs ?? []),
-		renderUrl,
-	];
-}