@beryl-so/cli 0.67.0 → 0.77.1

package/dist/playwright-install.js

@@ -1,220 +0,0 @@
-import { spawn } from "node:child_process";
-import fs from "node:fs";
-import { createRequire } from "node:module";
-import os from "node:os";
-import path from "node:path";
-// The two commands that turn "nothing Playwright-related installed" into "local runs work":
-// the test runner as a dev dep, then its browser binary. Kept as data so the CLI can both
-// run them and print them verbatim for the non-interactive / copy-paste path.
-export const INSTALL_TEST_RUNNER = ["npm", "i", "-D", "@playwright/test"];
-export const INSTALL_CHROMIUM = ["npx", "playwright", "install", "chromium"];
-export const PLAYWRIGHT_INSTALL_COMMANDS = `${INSTALL_TEST_RUNNER.join(" ")} && ${INSTALL_CHROMIUM.join(" ")}`;
-// Resolve from the project tree, not from wherever the globally-installed CLI happens to
-// live — `createRequire` rooted at cwd walks up the same node_modules chain Playwright will.
-const projectRequire = (cwd) => createRequire(path.join(cwd, "package.json"));
-// @playwright/test is a dependency of the CLI, so a repo needs nothing installed to run
-// locally: the runner comes with `npx @beryl-so/cli`, and only the browser is per-machine.
-// A repo's own @playwright/test still wins when present (its version, its browser revision).
-const cliRequire = createRequire(import.meta.url);
-// cli.js is the package's bin, not an export, so it is located via package.json.
-function runnerAt(pkgPath, source) {
-    const { version } = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-    return { cli: path.join(path.dirname(pkgPath), "cli.js"), version, source };
-}
-function projectRunner(dir) {
-    try {
-        return runnerAt(projectRequire(dir).resolve("@playwright/test/package.json"), "project");
-    }
-    catch {
-        return undefined;
-    }
-}
-function bundledRunner() {
-    try {
-        return runnerAt(cliRequire.resolve("@playwright/test/package.json"), "bundled");
-    }
-    catch {
-        return undefined;
-    }
-}
-// The single answer to "which @playwright/test": what `import "@playwright/test"` from `dir`
-// resolves to (any ancestor's node_modules), else the bundled copy. Runner and spec must load
-// the same one or Playwright refuses to run ("did not expect test.use() to be called here").
-export function resolvePlaywrightRunner(dir) {
-    return projectRunner(dir) ?? bundledRunner();
-}
-export const bundledRunnerCli = () => bundledRunner()?.cli;
-// By hand, the browser must be fetched for the runner that will launch it: the repo's own
-// (`npx playwright` resolves it) or, in a bare repo, the CLI's pinned version. An unpinned
-// `npx playwright install` there downloads the registry's latest revision, which is not it.
-export function browserInstallCommand(cwd) {
-    const bundled = bundledRunner();
-    if (hasPlaywrightTest(cwd) || !bundled)
-        return INSTALL_CHROMIUM.join(" ");
-    const [npx, pkg, ...rest] = INSTALL_CHROMIUM;
-    return [npx, `${pkg}@${bundled.version}`, ...rest].join(" ");
-}
-function bundledCoreDir() {
-    try {
-        return path.dirname(cliRequire.resolve("playwright-core/package.json"));
-    }
-    catch {
-        return undefined;
-    }
-}
-export const hasPlaywrightTest = (cwd) => projectRunner(cwd) !== undefined;
-// A local run launches chromium headless, which Playwright serves from a separate
-// `chromium_headless_shell` build (`playwright install chromium` fetches both). That is the
-// only engine a run ever launches, so it is the only one we install or check for.
-const HEADLESS_SHELL = "chromium-headless-shell";
-// Written last by Playwright's downloader, so its presence means a complete browser.
-const INSTALL_MARKER = "INSTALLATION_COMPLETE";
-function playwrightCoreDir(cwd) {
-    const req = projectRequire(cwd);
-    try {
-        return path.dirname(req.resolve("playwright-core/package.json"));
-    }
-    catch {
-        // Not hoisted (pnpm) — look from @playwright/test's own tree instead.
-    }
-    try {
-        const fromRunner = createRequire(req.resolve("@playwright/test"));
-        return path.dirname(fromRunner.resolve("playwright-core/package.json"));
-    }
-    catch {
-        return undefined;
-    }
-}
-// Mirrors playwright-core's registry root: PLAYWRIGHT_BROWSERS_PATH ("0" means inside the
-// package), else the per-platform cache dir. undefined on a platform Playwright doesn't
-// support, where we have no verdict to offer.
-function browsersRoot(coreDir) {
-    const override = process.env.PLAYWRIGHT_BROWSERS_PATH;
-    if (override === "0")
-        return coreDir ? path.join(coreDir, ".local-browsers") : undefined;
-    if (override)
-        return path.resolve(override);
-    const home = os.homedir();
-    if (process.platform === "darwin")
-        return path.join(home, "Library", "Caches", "ms-playwright");
-    if (process.platform === "win32") {
-        const local = process.env.LOCALAPPDATA || path.join(home, "AppData", "Local");
-        return path.join(local, "ms-playwright");
-    }
-    if (process.platform === "linux") {
-        return path.join(process.env.XDG_CACHE_HOME || path.join(home, ".cache"), "ms-playwright");
-    }
-    return undefined;
-}
-// The exact directory this project's Playwright will look in: <root>/<browser name with
-// dashes as underscores>-<revision>, straight out of playwright-core's browsers.json — so a
-// browser downloaded for an older Playwright doesn't read as the one this one needs.
-function wantedChromiumDir(coreDir) {
-    if (!coreDir)
-        return undefined;
-    try {
-        const parsed = JSON.parse(fs.readFileSync(path.join(coreDir, "browsers.json"), "utf8"));
-        const entry = parsed.browsers?.find((b) => b.name === HEADLESS_SHELL) ??
-            parsed.browsers?.find((b) => b.name === "chromium");
-        if (!entry?.name || !entry.revision)
-            return undefined;
-        return `${entry.name.replace(/-/g, "_")}-${entry.revision}`;
-    }
-    catch {
-        return undefined;
-    }
-}
-const isComplete = (dir) => fs.existsSync(path.join(dir, INSTALL_MARKER));
-/**
- * Is the browser binary a local run actually launches present? Without it every test in a
- * run dies with the same `browserType.launch: Executable doesn't exist` — an environment
- * problem that reads as a broken suite.
- */
-export function hasChromiumBrowser(cwd) {
-    const coreDir = hasPlaywrightTest(cwd) ? playwrightCoreDir(cwd) : bundledCoreDir();
-    const root = browsersRoot(coreDir);
-    // Nowhere known to look — say nothing rather than block; the run surfaces Playwright's
-    // own error if it really is missing.
-    if (!root)
-        return true;
-    const wanted = wantedChromiumDir(coreDir);
-    if (wanted)
-        return isComplete(path.join(root, wanted));
-    // Revision unknown (no resolvable playwright-core): any completed chromium build is the
-    // best evidence there is, and guessing wrong only costs an idempotent re-install.
-    try {
-        return fs
-            .readdirSync(root)
-            .some((d) => /^chromium(_headless_shell)?-\d+$/.test(d) && isComplete(path.join(root, d)));
-    }
-    catch {
-        return false;
-    }
-}
-export function playwrightGaps(cwd) {
-    const runner = !hasPlaywrightTest(cwd) && !bundledRunnerCli();
-    // With no runner there is no revision to judge a cached browser against, so the honest
-    // answer is the full install — not the npm half and a second failure right after it.
-    return { runner, browser: runner || !hasChromiumBrowser(cwd) };
-}
-export const anyGap = (gaps) => gaps.runner || gaps.browser;
-export function describeGaps(gaps) {
-    if (gaps.runner && gaps.browser)
-        return "@playwright/test + the Chromium browser";
-    return gaps.browser ? "the Chromium browser" : "@playwright/test";
-}
-/** Only the commands the missing halves need — a present @playwright/test isn't reinstalled. */
-export function installCommandsFor(gaps, cwd = process.cwd()) {
-    const commands = [
-        ...(gaps.runner ? [INSTALL_TEST_RUNNER.join(" ")] : []),
-        ...(gaps.browser ? [browserInstallCommand(cwd)] : []),
-    ];
-    return commands.length > 0 ? commands.join(" && ") : PLAYWRIGHT_INSTALL_COMMANDS;
-}
-export const installPrompt = (commands) => `Install local Playwright now (${commands})? [Y/n] `;
-export const INSTALL_PROMPT = installPrompt(PLAYWRIGHT_INSTALL_COMMANDS);
-// Ask (default-yes) whether to install. Returns false — not throwing — when there is no answer
-// or the prompt fails, so callers uniformly fall back to printing the install hint.
-export async function confirmInstall(prompt, commands = PLAYWRIGHT_INSTALL_COMMANDS) {
-    try {
-        return !/^n(o)?$/i.test(await prompt(installPrompt(commands)));
-    }
-    catch {
-        return false;
-    }
-}
-const withCmdExt = (cmd) => process.platform === "win32" && (cmd === "npm" || cmd === "npx") ? `${cmd}.cmd` : cmd;
-function runInherit(command, args, cwd) {
-    return new Promise((resolve, reject) => {
-        // stdio inherited: an install is slow and the user wants to watch npm/browser-download
-        // progress live, exactly as if they'd typed it themselves.
-        const child = spawn(withCmdExt(command), [...args], { cwd, stdio: "inherit" });
-        child.on("error", reject);
-        child.on("close", (code) => code === 0
-            ? resolve()
-            : reject(new Error(`\`${command} ${args.join(" ")}\` exited with code ${code}`)));
-    });
-}
-/**
- * Install the local Playwright test runner + chromium into `cwd`, streaming each step's output.
- * Throws if either step exits non-zero (so the caller surfaces the failure, not a silent partial
- * install). Skips the `@playwright/test` step when it is already resolvable, but always ensures
- * the browser binary — an installed runner with no browser still fails a real run.
- */
-export async function installPlaywright(cwd, onStep) {
-    const bundled = bundledRunnerCli();
-    if (!hasPlaywrightTest(cwd) && !bundled) {
-        onStep?.(`Installing @playwright/test — ${INSTALL_TEST_RUNNER.join(" ")}`);
-        await runInherit(INSTALL_TEST_RUNNER[0], INSTALL_TEST_RUNNER.slice(1), cwd);
-    }
-    onStep?.(`Installing the Chromium browser — ${browserInstallCommand(cwd)}`);
-    if (!hasPlaywrightTest(cwd) && bundled) {
-        await runInherit(process.execPath, [bundled, ...INSTALL_CHROMIUM.slice(2)], cwd);
-        return;
-    }
-    await runInherit(INSTALL_CHROMIUM[0], INSTALL_CHROMIUM.slice(1), cwd);
-}
-export function installHint(cwd, gaps = playwrightGaps(cwd)) {
-    const commands = installCommandsFor(gaps, cwd);
-    return `Local runs need ${describeGaps(gaps)}. Install it, then re-run:\n  ${commands}`;
-}

package/dist/progress.js

@@ -1,44 +0,0 @@
-import { dim } from "./output.js";
-const BAR_WIDTH = 18;
-export function renderProgressLine(state) {
-    const stepFraction = state.stepTotal && state.stepTotal > 0
-        ? Math.min(1, (state.step ?? 0) / state.stepTotal)
-        : 0;
-    const fraction = state.total > 0 ? Math.min(1, (state.done + stepFraction) / state.total) : 0;
-    const filled = Math.round(fraction * BAR_WIDTH);
-    const bar = "█".repeat(filled) + "░".repeat(BAR_WIDTH - filled);
-    const pct = `${Math.round(fraction * 100)}%`.padStart(4);
-    const steps = state.stepTotal && state.stepTotal > 0
-        ? ` · step ${Math.min(state.step ?? 0, state.stepTotal)}/${state.stepTotal}`
-        : "";
-    const tally = state.failed > 0 ? ` · ✓${state.passed} ✗${state.failed}` : ` · ✓${state.passed}`;
-    return `[${bar}]${pct} · test ${Math.min(state.done + 1, state.total)}/${state.total}${tally} · ${state.title}${steps}`;
-}
-/** A single rewriting status line on a TTY; quiet elsewhere (the caller prints
- *  per-test boundary lines instead, so MCP/CI logs stay readable). */
-export class ProgressBar {
-    stream;
-    lastLen = 0;
-    tty;
-    constructor(stream = process.stderr) {
-        this.stream = stream;
-        this.tty = Boolean(stream.isTTY);
-    }
-    get active() {
-        return this.tty;
-    }
-    update(state) {
-        if (!this.tty)
-            return;
-        const line = renderProgressLine(state);
-        const padded = line.padEnd(this.lastLen);
-        this.lastLen = line.length;
-        this.stream.write(`\r${dim(padded)}`);
-    }
-    clear() {
-        if (!this.tty || this.lastLen === 0)
-            return;
-        this.stream.write(`\r${" ".repeat(this.lastLen)}\r`);
-        this.lastLen = 0;
-    }
-}