mirror of
https://github.com/garrytan/gstack.git
synced 2026-09-19 11:22:21 +02:00
v1.81.0.0 feat: Aside is the browser gstack drives first; every browsing skill, the PDF/diagram renderer, and web research; the bundled browser stays the automatic fallback (#2810)
* feat(aside): browser-driver contract, cookbook, research and fallback resolvers
{{ASIDE_SETUP}} (readiness probe + ten rules for driving the user's real browser), {{ASIDE_COOKBOOK}} (script shapes verified live against Aside CLI 1.26: one flow per aside repl script, CDP console hook before navigation, evidence lines, session-directory artifact handoff, GSTACK_STEP_OK sentinel), {{ASIDE_RESEARCH}} (research through aside exec, WebSearch when Aside is absent, knowledge otherwise) and {{BROWSE_FALLBACK}} (the fifteen-row Aside-step to $B-command table plus the rules that differ, so every browsing skill keeps working on gstack's own headless browser). test/aside-driver.test.ts pins the sentences and asserts every browsing skill carries the Aside block followed by the fallback; test/helpers/aside-available.ts is the shared live-Aside probe.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* feat(render): Aside-first local-HTML renderer with the bundled browser as fallback
lib/aside-render.ts serves the HTML's directory on loopback (Aside refuses file:// URLs), opens it with waitUntil load, prints through CDP Page.printToPDF so tagged output, outlines, header/footer templates and page numbers survive, emulates device metrics for sized screenshots, and writes in-page evaluations to files; when Aside is absent it runs the same spec through the browse daemon (newtab, load, js, pdf, screenshot, closetab) and reports ENGINE=aside|browse. bin/gstack-render.ts is the CLI skill templates call. lib/claude-bin.ts and lib/error-handling.ts become the canonical copies (browse/src re-exports them).
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* refactor(browse): /browse drives Aside first, with the $B reference behind the fallback
Contract, cookbook, mode choice (aside repl by default, aside exec for reading), report format, the fallback section, and the full command reference carved on demand.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* refactor(qa): /qa and /qa-only drive Aside, fall back to $B
QA_METHODOLOGY runs every phase as Aside scripts (orient, explore, document, re-test, mobile viewport via CDP emulation, links via HEAD fetch); the authenticate phase is 'you are already signed in'; a 13th rule requires consent before mutating actions on non-local targets; the fallback section translates each step onto $B. The qa E2E tests run on whichever engine is present.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* refactor(design): design-review, design-consultation, design-shotgun, plan-design-review, design-html drive Aside
Design-system extraction is one script printing FONTS/COLORS/HEADINGS/TOUCH_TARGETS/NAV; competitor research confirms the exact URLs before opening them in the real browser and runs on the bundled browser when Aside is absent; design-html's viewport screenshots, sketches and comparison boards render through gstack-render.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* refactor(deploy): benchmark, canary, land-and-deploy Step 7, devex-review drive Aside
One aside repl script per page prints NAV/PAINT/LCP/RESOURCES/SCRIPTS/CSS/SUMMARY (benchmark), CONSOLE_ERRORS/NAV/TEXT + screenshot (canary, re-run every 60s), and the post-deploy check reads responseStatus from the navigation entry; each carries the $B fallback.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* feat(third-party-actions): Aside is the recommended driver; gstack's visible browser stays the fallback
The readiness probe is lifted from {{ASIDE_SETUP}} at gen time (byte-identity pinned) and rule 3 points at browse/SKILL.md for how to drive; the consent question offers Aside first and gstack's own visible browser (handoff/resume for sign-in) as the fallback, as v1.72 framed it.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* refactor(scrape): /scrape reads pages through Aside; the browser-skills runtime rides the fallback
Look-then-extract scripts build the JSON inside the page and print it between JSON_START/JSON_END; aside exec for fuzzy intents; on the $B fallback the browser-skills match/prototype flow and /skillify apply as before.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* refactor(make-pdf): print through Aside first, the bundled browser otherwise
asideClient.ts replaces the direct $B client with one render() call per PDF (the exact option mapping the browse pdf command had: paper, margins, header/footer/page numbers, tagged, outline, printBackground, preferCSSPageSize, Paged.js wait); the diagram pre-pass, oversized-image downscale and DOCX rasters each run as one render script with per-fence try/catch; exit 4 now means no browser is available and names both remedies; $P setup reports which engine it found. The e2e gates run on whichever engine is present, so the Linux lane exercises the fallback.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* refactor(diagram): the triplet is one gstack-render call
SVG, PNG and excalidraw from one invocation over the content-addressed bundle staged under /tmp/gstack-render; every diagram type gets an excalidraw export; gstack-render picks the engine and prints ENGINE=; the diagram E2E gates on either engine.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* feat(research): web research runs in Aside first, WebSearch second
The planning, review, design, security and investigate skills research through {{ASIDE_RESEARCH}}; WebSearch stays in allowed-tools as the fallback; testing.ts's bootstrap step follows; skeleton ceilings ratcheted for the research block.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* feat(setup,gen-skill-docs): prune renders of skills that no longer exist
setup gains _prune_stale_generated for every host tree and the doc generator removes gstack-* output dirs it did not write, so a skill removed from the source tree can never linger in an install.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* test: registries, budgets and suite reconciled for Aside-first with the $B fallback
Touchfiles + E2E tiers gain the Aside keys, coverage matrix and eval baselines updated, size budget re-baselined to parity-baseline-v1.80.0.0.json (the contract plus fallback ride in every browsing skill), parity ceilings ratcheted with measured values, LLM-judge prompts and the E2E fixtures speak Aside-first, browse-fallback.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* docs: Aside first, gstack browser fallback
README, BROWSER.md, docs/, CONTRIBUTING, CLAUDE.md, ARCHITECTURE, AGENTS.md, TODOS and the root router describe the one product story: Aside is the browser gstack drives first; the bundled headless browser is the automatic fallback (Linux, Windows, app closed) where cookie import, GStack Browser, pair-agent and browser-skills still apply.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* chore: regenerate SKILL.md docs, llms.txt, agents digest, ship goldens, context-budget fixture
bun run gen:skill-docs over the templates; goldens re-rendered; context-budget ceilings recaptured.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* v1.80.0.0: Aside is the browser gstack drives first; the bundled browser is the fallback
MINOR: new capability across ten skills, the renderer and research; nothing removed. CHANGELOG release summary + itemized changes; VERSION 1.80.0.0; package.json 1.80.0.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* docs(todos): file non-Claude host ownership-gate and version-heading pin follow-ups
Two follow-ups from the /plan-ceo-review + /plan-eng-review pass on merging
PR #2804 with main's v1.80.0.0 ownership gate: bring the Codex/Factory/
OpenCode/Cursor/Kiro copy loops and the stale-render prune under the
.gstack-owned marker rule, and a free test pinning that the CHANGELOG top
heading equals VERSION (the collision that git cannot see).
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* fix: pre-landing review fixes for the Aside-first branch
Review army + adversarial passes (Claude and Codex) on the merged branch:
setup
- _prune_stale_generated scans the host dirs too (the generator already
removed the render before setup ran, so the host branch was dead), skips
symlinks in the render tree (rm -rf on a slash-terminated link empties its
target), removes a host symlink only when it resolves into gstack, cleans a
bannered real dir through _cleanup_weak_dir, recognizes frontmatter-renamed
skills, and logs through log. The always-run codex render passes every host
dir that may link to it.
- NEEDS_BUILD checks all three binaries (with $_EXE) and lib/ sources; the
browser hint and the bootstrap summary honor GSTACK_SKIP_ASIDE, treat a
requested skip as a request, and derive one skill list.
lib/aside-render.ts + bin/gstack-render.ts
- The loopback server carries a per-render secret path, checks containment on
the real path (symlink escapes are 403), and rejects malformed encoding.
- Inline eval results are one base64 line, so page text cannot forge
ASIDE_DIR= or the sentinel; the last ASIDE_DIR wins.
- runProc escalates SIGTERM to SIGKILL, bounds every wait, and clears every
timer (an uncleared one kept gstack-render alive after printing OK).
- renderTmpDir refuses a shared /tmp name owned by someone else; the work dir
and server are created inside try; goto's budget follows the render budget.
- probeAside classifies a present-but-failing CLI as ASIDE_NOT_RUNNING like
the skills' bash probe; render() retries on gstack's own browser when Aside
could not start or its private CDP bridge is gone (never on a page error
or a timeout of a running script); the CLI reports the engine that actually
rendered, exits 0 on --help, rejects non-numeric flags, documents
--wait-timeout, fences EVAL/PAGE_ERRORS as untrusted content, and names the
daemon's cookie-import JS lock remedy.
- The browse path passes --scale only when asked (a scale change rebuilds
the daemon context) and restores the viewport after a sized screenshot.
resolvers / templates
- The bash probe honors GSTACK_SKIP_ASIDE and has a perl deadline on stock
macOS; .local is no longer LOCAL (mDNS); same-origin filters compare parsed
origins; link status is HEAD-checked only on LOCAL targets; every
aside exec goes through the receipted _aside_exec prelude
({{ASIDE_EXEC_PRELUDE}}), including nine template blocks that called it
bare; the design sketch and diagram staging use private directories.
- The generator prunes only bannered renders and never a host whose
generation failed.
Docs, stale comments and dead code cleaned; goldens re-rendered; tests
updated and added for every behavior above.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* test: coverage for the render CLI, setup rebuild check, make-pdf exit codes, and prose $B spans
New free tests from the ship coverage audit: test/gstack-render-cli.test.ts
(argv guards, --help, output contract with a fake daemon, failure and
serve-root paths, no-browser case, prompt exit), test/setup-needs-build.test.ts
(every binary and source set flips NEEDS_BUILD, Windows suffixes),
make-pdf/test/cli-exit-codes.test.ts and setup-smoke.test.ts (error to exit
code mapping, runSetup stages, renderPdf's engine), and prose-span cases for
extractBrowseCommands in test/skill-parser.test.ts.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* docs: CHANGELOG and TODOS cover the review fixes (v1.81.0.0)
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* docs: sync project docs with the v1.81.0.0 review fixes
BROWSER.md, ARCHITECTURE.md, CONTRIBUTING.md, README.md, CLAUDE.md,
docs/TESTING_INTERNALS.md and docs/PROJECT_STRUCTURE.md now describe the
shipped renderer and setup: the loopback render server's per-render secret
path and real-path containment, ENGINE= naming the engine that actually
rendered (mid-run retry on gstack's own browser), EVAL/PAGE_ERRORS fenced as
untrusted content, --wait-timeout and the CLI's argv guards, the receipted
_aside_exec prelude ({{ASIDE_EXEC_PRELUDE}} in the placeholder table), the
LOCAL host rule without .local, LOCAL-only HEAD checks in the links script,
GSTACK_SKIP_ASIDE across probe/renderer/setup, the ownership-gated
retired-skill prune, the widened NEEDS_BUILD check, and the new free tests
(gstack-render-cli, setup-prune-stale-generated, setup-browser-hint,
setup-needs-build, make-pdf cli-exit-codes and setup-smoke).
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* docs: CHANGELOG states the precise mid-run retry rule
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* fix(test): skill-e2e-bws slices the $B setup block from the Browser fallback section
browse/SKILL.md no longer has '## SETUP' / '## Core QA Patterns' (Aside is the
primary driver; the $B block moved under 'Browser fallback'), so the gate test
sliced an empty block and handed the agent nothing to run. Anchor on
'### Find the `$B` binary' up to the next heading. 7/7 pass.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* fix(test): gate POSIX-only fixtures off Windows
windows-free-tests: the gstack-render CLI tests drive a shebang fake browse
that CreateProcess cannot exec, and two NEEDS_BUILD cases assert an execute
bit and a bare-name miss that MSYS bash does not have (test -x ignores mode
bits and resolves design -> design.exe). Those describes and cases now
self-skip on win32; argument guards, --help, the no-browser case, and every
other rebuild-check case still run there.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* fix(render): runProc waits for the exit code until the kill deadline; newtab retries once on a cold daemon
A process whose pipes have reached EOF is exiting, but runProc gave the exit
code only five seconds to arrive and then returned null, which run() reports
as a failed command. Under CI's six-shard load one such render failed with the
artifact already written. The SIGTERM/SIGKILL timers already bound the wait,
so the exit race now runs to the kill deadline.
The first CLI call auto-starts the browse daemon; on a cold start it can
answer 'Unable to connect' once while the server is still coming up. That
single case is retried after 1.5s; every other newtab failure is not.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* test(aside-render): warm the daemon before live fallback cases; failures name the render error
- Live fallback cases run 'goto about:blank' up to twice before asserting and
skip (never fail) when the daemon cannot come up.
- expectOk() puts r.error and the browse transcript into the assertion so a
failed render is diagnosable from the CI log.
- The argv-contract cases dump the fake's log on a miss.
- File default timeout is 30s: the subject is the CLI contract, not latency.
- Two cases pin the cold-daemon newtab retry and that other errors are not
retried.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
* docs: CHANGELOG notes the cold-start tolerance of the bundled-browser renderer
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---------
Co-authored-by: Sina <sdroid674+github@gmail.com>
Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
This commit is contained in:
Garry Tan
co-authored by
Claude Fable 5.1
Sina
Claude Fable 5.1
Sina
parent
c241216637
commit
0530392821
@@ -0,0 +1,259 @@
|
||||
/**
|
||||
* `$P setup` smoke flow — make-pdf/src/setup.ts runSetup() — with no real
|
||||
* browser probed or launched.
|
||||
*
|
||||
* runSetup() reads the engine through lib/aside-render's process-wide cache
|
||||
* (pickEngine() with no arguments, and render() which consults the same
|
||||
* cache), so `pickEngine(true, deps)` is the intended seam: prime it once with
|
||||
* a stubbed Aside probe and a stubbed browse-binary resolver, then call
|
||||
* runSetup(). A fake `browse` shell script plays gstack's own headless
|
||||
* browser for the [2/5] render smoke and the [4/5] smoke PDF. process.exit is
|
||||
* stubbed to throw so the exit code is observable; process.stderr.write is
|
||||
* captured for the step lines.
|
||||
*
|
||||
* Also pins renderPdf()'s return value — the engine that actually rendered —
|
||||
* which the orchestrator compares against the engine it announced.
|
||||
*/
|
||||
|
||||
import { afterAll, beforeAll, describe, expect, test } from "bun:test";
|
||||
import * as fs from "node:fs";
|
||||
import * as os from "node:os";
|
||||
import * as path from "node:path";
|
||||
|
||||
import {
|
||||
NO_BROWSER,
|
||||
NO_BROWSER_HELP,
|
||||
pickEngine,
|
||||
renderTmpDir,
|
||||
type AsideProbe,
|
||||
type RenderResult,
|
||||
type RenderSpec,
|
||||
} from "../../lib/aside-render";
|
||||
import { renderPdf } from "../src/asideClient";
|
||||
import { OUTPUT_TMP_DIR } from "../src/orchestrator";
|
||||
import { runSetup } from "../src/setup";
|
||||
import { ExitCode } from "../src/types";
|
||||
|
||||
const isWin = process.platform === "win32";
|
||||
const PROBE_DETAIL = "primed by setup-smoke.test.ts";
|
||||
const noAside = (): AsideProbe => ({ ok: false, reason: "NEEDS_ASIDE", detail: PROBE_DETAIL });
|
||||
|
||||
let tmp: string;
|
||||
|
||||
beforeAll(() => {
|
||||
tmp = fs.mkdtempSync(path.join(os.tmpdir(), "make-pdf-setup-smoke-"));
|
||||
});
|
||||
|
||||
afterAll(() => {
|
||||
fs.rmSync(tmp, { recursive: true, force: true });
|
||||
// The engine cache is process-wide. The free runner gives every test file
|
||||
// its own process, but under a bare multi-file `bun test` a later in-process
|
||||
// caller must not inherit a fake binary that no longer exists: re-resolve
|
||||
// gstack's real browse binary (Aside probe still stubbed — never a round-trip).
|
||||
pickEngine(true, { probe: noAside });
|
||||
});
|
||||
|
||||
// ─── helpers ──────────────────────────────────────────────────────────────────
|
||||
|
||||
class ExitSentinel extends Error {
|
||||
constructor(readonly code: number) {
|
||||
super(`process.exit(${code})`);
|
||||
this.name = "ExitSentinel";
|
||||
}
|
||||
}
|
||||
|
||||
/** Run `fn` with process.exit throwing a sentinel and process.stderr.write captured. Restores both. */
|
||||
async function captureRun<T>(fn: () => Promise<T>): Promise<{ result?: T; exit?: number; error?: unknown; stderr: string }> {
|
||||
const chunks: string[] = [];
|
||||
const origWrite = process.stderr.write;
|
||||
const origExit = process.exit;
|
||||
process.stderr.write = ((chunk: string | Uint8Array) => {
|
||||
chunks.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8"));
|
||||
return true;
|
||||
}) as typeof process.stderr.write;
|
||||
process.exit = ((code?: number) => {
|
||||
throw new ExitSentinel(code ?? 0);
|
||||
}) as typeof process.exit;
|
||||
try {
|
||||
const result = await fn();
|
||||
return { result, stderr: chunks.join("") };
|
||||
} catch (e) {
|
||||
if (e instanceof ExitSentinel) return { exit: e.code, stderr: chunks.join("") };
|
||||
return { error: e, stderr: chunks.join("") };
|
||||
} finally {
|
||||
process.stderr.write = origWrite;
|
||||
process.exit = origExit;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* A stand-in for gstack's browse daemon CLI: `newtab --json` hands out a tab,
|
||||
* `js` answers with `pageText`, `pdf --from-file <payload>` writes a fake PDF
|
||||
* at the payload's `output` path when `pdf` is set (and nothing otherwise).
|
||||
*/
|
||||
function writeFakeBrowse(name: string, opts: { pageText?: string; pdf?: boolean; newtabFails?: boolean }): string {
|
||||
const body = ["#!/bin/sh", 'case "$1" in'];
|
||||
body.push(opts.newtabFails
|
||||
? ' newtab) echo "daemon refused: boom" >&2; exit 1 ;;'
|
||||
: ` newtab) echo '{"tabId":7}' ;;`);
|
||||
body.push(` js) echo '${opts.pageText ?? "browser-ok"}' ;;`);
|
||||
if (opts.pdf) {
|
||||
body.push(
|
||||
" pdf)",
|
||||
' read -r payload < "$3"',
|
||||
' out="${payload#*\\"output\\":\\"}"',
|
||||
' out="${out%%\\"*}"',
|
||||
" printf '%%PDF-1.4 fake\\n' > \"$out\"",
|
||||
" ;;",
|
||||
);
|
||||
}
|
||||
body.push("esac", "exit 0", "");
|
||||
const file = path.join(tmp, name);
|
||||
fs.writeFileSync(file, body.join("\n"), { mode: 0o755 });
|
||||
return file;
|
||||
}
|
||||
|
||||
/** The [2/5] smoke staging dirs currently under renderTmpDir(). */
|
||||
function smokeDirs(stage: string): string[] {
|
||||
return fs.readdirSync(stage).filter((n) => n.startsWith("make-pdf-setup-")).sort();
|
||||
}
|
||||
|
||||
const smokePdf = () => path.join(OUTPUT_TMP_DIR, `make-pdf-smoke-${process.pid}.pdf`);
|
||||
const smokeFixture = () => path.join(OUTPUT_TMP_DIR, `make-pdf-smoke-${process.pid}.md`);
|
||||
|
||||
// ─── [1/5] browser check ──────────────────────────────────────────────────────
|
||||
|
||||
describe("runSetup [1/5]: no browser at all", () => {
|
||||
test("Aside absent and no browse binary: FAIL, the NO_BROWSER text with both remedies, exit 4, never reaches [2/5]", async () => {
|
||||
pickEngine(true, { probe: noAside, resolveBin: () => null });
|
||||
const run = await captureRun(() => runSetup());
|
||||
expect(run.error).toBeUndefined();
|
||||
expect(run.exit).toBe(ExitCode.BrowserUnavailable);
|
||||
expect(run.exit).toBe(4);
|
||||
expect(run.stderr).toContain("make-pdf setup — verifying install");
|
||||
expect(run.stderr).toContain("[1/5] Checking for a browser... FAIL");
|
||||
expect(run.stderr).toContain(NO_BROWSER);
|
||||
expect(run.stderr).toContain("no browser available");
|
||||
expect(run.stderr).toContain(NO_BROWSER_HELP);
|
||||
expect(run.stderr).toContain(`(NEEDS_ASIDE: ${PROBE_DETAIL})`);
|
||||
expect(run.stderr).not.toContain("[2/5]");
|
||||
});
|
||||
});
|
||||
|
||||
// ─── [2/5] render smoke through the fallback browser ──────────────────────────
|
||||
|
||||
describe.skipIf(isWin)("runSetup [2/5]: render smoke through gstack's own browser", () => {
|
||||
test("a browser that answers but the page text is wrong: FAIL, `could not render a page` + remedy, exit 4, smoke dir removed", async () => {
|
||||
const fake = writeFakeBrowse("browse-wrong-text", { pageText: "not-the-smoke-page" });
|
||||
pickEngine(true, { probe: noAside, resolveBin: () => fake });
|
||||
const stage = renderTmpDir();
|
||||
const before = smokeDirs(stage);
|
||||
|
||||
const run = await captureRun(() => runSetup());
|
||||
expect(run.error).toBeUndefined();
|
||||
expect(run.exit).toBe(ExitCode.BrowserUnavailable);
|
||||
expect(run.stderr).toContain(`[1/5] Checking for a browser... gstack browser OK (fallback: ${fake}; Aside is not running)`);
|
||||
expect(run.stderr).toContain("[2/5] Rendering through gstack browser... FAIL");
|
||||
expect(run.stderr).toContain("gstack browser could not render a page: unexpected page text: not-the-smoke-page");
|
||||
expect(run.stderr).toContain(`To fix: ${NO_BROWSER_HELP}`);
|
||||
expect(run.stderr).toContain("open the Aside app");
|
||||
expect(run.stderr).toContain("./setup");
|
||||
expect(run.stderr).not.toContain("[3/5]");
|
||||
expect(smokeDirs(stage)).toEqual(before); // finally { rmSync(smokeDir) } ran despite the exit
|
||||
});
|
||||
|
||||
test("a daemon that refuses to open a tab surfaces browse's own error on the same FAIL path (exit 4)", async () => {
|
||||
const fake = writeFakeBrowse("browse-refuses-newtab", { newtabFails: true });
|
||||
pickEngine(true, { probe: noAside, resolveBin: () => fake });
|
||||
const stage = renderTmpDir();
|
||||
const before = smokeDirs(stage);
|
||||
|
||||
const run = await captureRun(() => runSetup());
|
||||
expect(run.exit).toBe(ExitCode.BrowserUnavailable);
|
||||
expect(run.stderr).toContain("[2/5] Rendering through gstack browser... FAIL");
|
||||
expect(run.stderr).toContain("gstack browser could not render a page: browse newtab failed: daemon refused: boom");
|
||||
expect(run.stderr).toContain(`To fix: ${NO_BROWSER_HELP}`);
|
||||
expect(smokeDirs(stage)).toEqual(before);
|
||||
});
|
||||
});
|
||||
|
||||
// ─── [3/5]–[5/5] the rest of the flow with a fake browser ─────────────────────
|
||||
|
||||
describe.skipIf(isWin)("runSetup [3/5]-[5/5]: pdftotext, smoke PDF, cheatsheet", () => {
|
||||
test("happy path: every step reports, the smoke PDF lands at OUTPUT_TMP_DIR, the fixture is removed, no exit", async () => {
|
||||
const fake = writeFakeBrowse("browse-happy", { pageText: "browser-ok", pdf: true });
|
||||
pickEngine(true, { probe: noAside, resolveBin: () => fake });
|
||||
const outPath = smokePdf();
|
||||
const fixturePath = smokeFixture();
|
||||
try {
|
||||
const run = await captureRun(() => runSetup());
|
||||
expect(run.error).toBeUndefined();
|
||||
expect(run.exit).toBeUndefined();
|
||||
expect(run.stderr).toContain(`[1/5] Checking for a browser... gstack browser OK (fallback: ${fake}; Aside is not running)`);
|
||||
expect(run.stderr).toContain("[2/5] Rendering through gstack browser... OK");
|
||||
// pdftotext is optional: OK where poppler is installed, SKIP with install hints otherwise.
|
||||
expect(run.stderr).toMatch(/\[3\/5\] Checking pdftotext \(optional\)\.\.\. (OK \(|SKIP\n)/);
|
||||
expect(run.stderr).toContain("[4/5] Generating smoke-test PDF...");
|
||||
expect(run.stderr).toContain(`PASSED. Smoke test saved to ${outPath}`);
|
||||
expect(run.stderr).toContain("[5/5] All checks passed.");
|
||||
expect(run.stderr).toContain("make-pdf is ready. Try:");
|
||||
expect(run.stderr).toContain(`Smoke-test PDF: ${outPath}`);
|
||||
// The announced engine (browse) is the one that rendered: no mid-run note.
|
||||
expect(run.stderr).not.toContain("mid-run");
|
||||
expect(fs.readFileSync(outPath, "utf8")).toBe("%PDF-1.4 fake\n");
|
||||
expect(fs.existsSync(fixturePath)).toBe(false);
|
||||
} finally {
|
||||
fs.rmSync(outPath, { force: true });
|
||||
fs.rmSync(fixturePath, { force: true });
|
||||
}
|
||||
});
|
||||
|
||||
test("[4/5] smoke PDF failure (browser up, print produced nothing): FAILED with the render error, exit 2, fixture removed", async () => {
|
||||
// Same fake, but `pdf` writes no artifact — a render error, not a missing browser.
|
||||
const fake = writeFakeBrowse("browse-no-artifact", { pageText: "browser-ok", pdf: false });
|
||||
pickEngine(true, { probe: noAside, resolveBin: () => fake });
|
||||
const outPath = smokePdf();
|
||||
const fixturePath = smokeFixture();
|
||||
try {
|
||||
const run = await captureRun(() => runSetup());
|
||||
expect(run.error).toBeUndefined();
|
||||
expect(run.exit).toBe(ExitCode.RenderError);
|
||||
expect(run.exit).toBe(2);
|
||||
expect(run.stderr).toContain("[2/5] Rendering through gstack browser... OK");
|
||||
expect(run.stderr).toContain("[4/5] Generating smoke-test PDF...");
|
||||
expect(run.stderr).toContain(" FAILED: PDF render failed: step 0 produced no artifact");
|
||||
expect(run.stderr).not.toContain("[5/5]");
|
||||
expect(fs.existsSync(outPath)).toBe(false);
|
||||
expect(fs.existsSync(fixturePath)).toBe(false); // finally { unlinkSync(fixturePath) } ran despite the exit
|
||||
} finally {
|
||||
fs.rmSync(outPath, { force: true });
|
||||
fs.rmSync(fixturePath, { force: true });
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
// ─── renderPdf returns the engine that rendered ───────────────────────────────
|
||||
|
||||
describe("renderPdf reports which engine rendered", () => {
|
||||
const injected = (engine: RenderResult["engine"]) => async (spec: RenderSpec): Promise<RenderResult> => {
|
||||
const step = spec.steps[0];
|
||||
return { ok: true, engine, outputs: step.kind === "pdf" ? [step.out] : [], evals: {}, stdout: "" };
|
||||
};
|
||||
|
||||
test("resolves 'browse' when gstack's own browser printed the PDF", async () => {
|
||||
await expect(renderPdf("<p>x</p>", { output: path.join(tmp, "browse.pdf") }, injected("browse"))).resolves.toBe("browse");
|
||||
});
|
||||
|
||||
test("resolves 'aside' when Aside printed it", async () => {
|
||||
await expect(renderPdf("<p>x</p>", { output: path.join(tmp, "aside.pdf") }, injected("aside"))).resolves.toBe("aside");
|
||||
});
|
||||
|
||||
test("resolves undefined when the result names no engine (older render shapes)", async () => {
|
||||
await expect(renderPdf("<p>x</p>", { output: path.join(tmp, "none.pdf") }, injected(undefined))).resolves.toBeUndefined();
|
||||
});
|
||||
|
||||
test("a failed result still throws (the engine is never returned for a failure)", async () => {
|
||||
const failing = async (): Promise<RenderResult> => ({ ok: false, engine: "browse", outputs: [], evals: {}, stdout: "", error: "browse pdf failed: boom" });
|
||||
await expect(renderPdf("<p>x</p>", { output: path.join(tmp, "fail.pdf") }, failing)).rejects.toThrow(/PDF render failed: browse pdf failed: boom/);
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user