prose-qa 0.1.0 → 0.2.2

package/pqa.config.ts

@@ -6,15 +6,6 @@
 const config = {
   scenariosDir: "scenarios",
   llm: {
-    provider:
-      (process.env.PQA_LLM_PROVIDER as
-        | "anthropic"
-        | "openai"
-        | "fireworks"
-        | "ollama"
-        | "google"
-        | "openrouter") ?? "anthropic",
-    model: process.env.PQA_LLM_MODEL ?? "claude-sonnet-4-20250514",
     thinking: {
       enabled: true,
       budgetTokens: 10_000,
@@ -26,16 +17,20 @@ const config = {
     defaultTimeout: 25_000,
     engine: "chrome",
     lightpanda: {
-      executablePath: "./bin",
+      executablePath: "./.pqa/engine",
       telemetry: false,
     },
   },
-  systemPromptPath: "prompt/SYSTEM.md",
   envVars: [],
   sensitiveEnvVars: [],
   skills: {
-    dirs: ["skills"],
-    preloads: ["core"],
+    dirs: [".pqa/skills"],
+    preloads: [],
+    onDemand: {
+      enabled: true,
+      autoLoad: true,
+      maxChars: 50_000,
+    },
   },
   agent: {
     parallel: 0,

package/prompt/SYSTEM.md

@@ -5,7 +5,8 @@ You are ProseQA, an E2E regression testing agent. Execute scenarios using
 
 ## Rules
 
-- Use `agent-browser` CLI for all browser interactions (see the core skill below).
+- Use `agent-browser` CLI for all browser interactions (see the minimal core skill below).
+- Use the `load_skill` tool for detailed references and custom project skills — do **not** run `agent-browser skills get` in bash.
 - Do NOT use curl, wget, or other HTTP clients to test the web UI.
 - After completing Steps, verify every Then checkpoint using agent-browser CLI.
 - On failure, save screenshot and snapshot to `$PQA_ARTIFACT_DIR`.

package/scripts/install-lightpanda.mjs

@@ -0,0 +1,161 @@
+/**
+ * Download the Lightpanda browser binary for the current OS/arch.
+ * @see https://lightpanda.io/docs/open-source/installation
+ * @see https://github.com/lightpanda-io/browser/releases/tag/nightly
+ */
+
+import { execSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { chmod, mkdir, rename, unlink } from "node:fs/promises";
+import { createWriteStream } from "node:fs";
+import { pipeline } from "node:stream/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const REPO = "lightpanda-io/browser";
+const VERSION = process.env.LIGHTPANDA_VERSION ?? "nightly";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.join(__dirname, "..");
+const installDir = process.env.LIGHTPANDA_DIR ?? path.join(projectRoot, ".bin");
+const binaryName = process.platform === "win32" ? "lightpanda.exe" : "lightpanda";
+const binaryPath = path.join(installDir, binaryName);
+
+function isMuslLinux() {
+  if (process.platform !== "linux") return false;
+  try {
+    const out = execSync("ldd --version 2>&1 || true", { encoding: "utf8" });
+    return out.toLowerCase().includes("musl");
+  } catch {
+    return false;
+  }
+}
+
+/** @returns {string} GitHub release asset basename (e.g. lightpanda-aarch64-macos) */
+function resolveAssetName() {
+  const { platform, arch } = process;
+
+  if (platform === "win32") {
+    console.error(
+      "Lightpanda has no native Windows binary. Install inside WSL2 (Linux steps), then point AGENT_BROWSER_EXECUTABLE_PATH at the WSL binary.\n" +
+        "https://lightpanda.io/docs/open-source/installation#windows--wsl2",
+    );
+    process.exit(1);
+  }
+
+  if (platform === "linux" && isMuslLinux()) {
+    console.error(
+      "Alpine/musl Linux is not supported by the prebuilt Lightpanda binaries (glibc required).\n" +
+        "Use a glibc-based image (Debian/Ubuntu) or build from source: https://github.com/lightpanda-io/browser#build-from-sources",
+    );
+    process.exit(1);
+  }
+
+  let osSuffix;
+  if (platform === "linux") osSuffix = "linux";
+  else if (platform === "darwin") osSuffix = "macos";
+  else {
+    console.error(`Unsupported platform: ${platform}`);
+    process.exit(1);
+  }
+
+  let archSuffix;
+  switch (arch) {
+    case "x64":
+      archSuffix = "x86_64";
+      break;
+    case "arm64":
+      archSuffix = "aarch64";
+      break;
+    default:
+      console.error(`Unsupported CPU architecture: ${arch}`);
+      process.exit(1);
+  }
+
+  return `lightpanda-${archSuffix}-${osSuffix}`;
+}
+
+async function fetchJson(url) {
+  const res = await fetch(url, {
+    headers: { Accept: "application/vnd.github+json", "User-Agent": "prose-qa-install-lightpanda" },
+  });
+  if (!res.ok) {
+    throw new Error(`GitHub API ${res.status} for ${url}`);
+  }
+  return res.json();
+}
+
+async function sha256File(filePath) {
+  const { createReadStream } = await import("node:fs");
+  const hash = createHash("sha256");
+  await new Promise((resolve, reject) => {
+    createReadStream(filePath)
+      .on("data", (chunk) => hash.update(chunk))
+      .on("end", resolve)
+      .on("error", reject);
+  });
+  return hash.digest("hex");
+}
+
+async function downloadToFile(url, dest) {
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`Download failed (${res.status}): ${url}`);
+  }
+  if (!res.body) {
+    throw new Error(`Empty response body: ${url}`);
+  }
+  await pipeline(res.body, createWriteStream(dest));
+}
+
+async function main() {
+  const assetName = resolveAssetName();
+  const downloadUrl = `https://github.com/${REPO}/releases/download/${VERSION}/${assetName}`;
+
+  console.log("=== Lightpanda install ===");
+  console.log(`Version: ${VERSION}`);
+  console.log(`Detected: ${process.platform} ${process.arch} → ${assetName}`);
+  console.log(`Install dir: ${installDir}`);
+
+  const release = await fetchJson(`https://api.github.com/repos/${REPO}/releases/tags/${VERSION}`);
+  const asset = release.assets?.find((a) => a.name === assetName);
+  if (!asset?.digest) {
+    throw new Error(`No checksum for asset "${assetName}" on release tag "${VERSION}"`);
+  }
+
+  const expectedSha256 = asset.digest.replace(/^sha256:/, "");
+  await mkdir(installDir, { recursive: true });
+
+  const tmpPath = `${binaryPath}.download`;
+  try {
+    console.log(`Downloading ${downloadUrl} ...`);
+    await downloadToFile(downloadUrl, tmpPath);
+
+    const actualSha256 = await sha256File(tmpPath);
+    if (actualSha256 !== expectedSha256) {
+      throw new Error(
+        `Checksum mismatch for ${assetName}\n  expected: ${expectedSha256}\n  actual:   ${actualSha256}`,
+      );
+    }
+
+    await rename(tmpPath, binaryPath);
+    await chmod(binaryPath, 0o755);
+
+    console.log("Checksum OK.");
+    console.log(`Installed: ${binaryPath}`);
+    console.log("");
+    console.log("Add to PATH (shell profile) or set for Prose-QA / agent-browser:");
+    console.log(`  export PATH="${installDir}:$PATH"`);
+    console.log(`  export AGENT_BROWSER_EXECUTABLE_PATH="${binaryPath}"`);
+    console.log("");
+    console.log("Start CDP server: lightpanda serve --host 127.0.0.1 --port 9222");
+  } catch (err) {
+    await unlink(tmpPath).catch(() => {});
+    throw err;
+  }
+}
+
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : err);
+  process.exit(1);
+});

package/scripts/sync-skills.mjs

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+/**
+ * Vendor agent-browser skills into skills/agent-browser/.
+ * - Minimal core SKILL.md (not --full inline dump)
+ * - references/ and templates/ for on-demand loading
+ * - bundled/ for optional specialized skills (dogfood, electron, …)
+ */
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(__dirname, "..");
+
+function resolveSkillDataRoot() {
+  const require = createRequire(path.join(repoRoot, "package.json"));
+  const pkgJson = require.resolve("agent-browser/package.json");
+  return path.join(path.dirname(pkgJson), "skill-data");
+}
+
+function copyDir(src, dest) {
+  if (!existsSync(src)) return;
+  mkdirSync(path.dirname(dest), { recursive: true });
+  cpSync(src, dest, { recursive: true });
+}
+
+function listFiles(dir, ext) {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter((name) => name.endsWith(ext))
+    .map((name) => name.slice(0, -ext.length))
+    .sort();
+}
+
+function readSkillDescription(skillDir) {
+  const skillPath = path.join(skillDir, "SKILL.md");
+  if (!existsSync(skillPath)) return "";
+  const raw = readFileSync(skillPath, "utf8");
+  const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(raw);
+  if (!match) return "";
+  for (const line of match[1].split("\n")) {
+    const desc = /^description:\s*(.+)$/.exec(line.trim());
+    if (desc) return desc[1].trim();
+  }
+  return "";
+}
+
+function syncSkills() {
+  const skillDataRoot = resolveSkillDataRoot();
+  if (!existsSync(skillDataRoot)) {
+    console.error("agent-browser skill-data not found. Run: npm install");
+    process.exit(1);
+  }
+
+  const outDir = path.join(repoRoot, "skills", "agent-browser");
+  const coreSrc = path.join(skillDataRoot, "core");
+
+  if (!existsSync(path.join(coreSrc, "SKILL.md"))) {
+    console.error("core/SKILL.md missing in agent-browser skill-data");
+    process.exit(1);
+  }
+
+  rmSync(outDir, { recursive: true, force: true });
+  mkdirSync(outDir, { recursive: true });
+
+  cpSync(path.join(coreSrc, "SKILL.md"), path.join(outDir, "SKILL.md"));
+  copyDir(path.join(coreSrc, "references"), path.join(outDir, "references"));
+  copyDir(path.join(coreSrc, "templates"), path.join(outDir, "templates"));
+
+  const bundledDir = path.join(outDir, "bundled");
+  mkdirSync(bundledDir, { recursive: true });
+
+  const bundled = [];
+  for (const name of readdirSync(skillDataRoot)) {
+    if (name === "core") continue;
+    const src = path.join(skillDataRoot, name);
+    if (!statSync(src).isDirectory()) continue;
+    const dest = path.join(bundledDir, name);
+    copyDir(src, dest);
+    bundled.push({
+      name,
+      description: readSkillDescription(src),
+    });
+  }
+  bundled.sort((a, b) => a.name.localeCompare(b.name));
+
+  const manifest = {
+    version: 1,
+    core: {
+      references: listFiles(path.join(outDir, "references"), ".md"),
+      templates: listFiles(path.join(outDir, "templates"), ".sh"),
+    },
+    bundled,
+  };
+
+  writeFileSync(
+    path.join(outDir, "manifest.json"),
+    `${JSON.stringify(manifest, null, 2)}\n`,
+    "utf8",
+  );
+
+  const coreLines = readFileSync(path.join(outDir, "SKILL.md"), "utf8").split("\n").length;
+  console.log(
+    `Synced agent-browser skills → skills/agent-browser/ (core: ${coreLines} lines, ` +
+      `${manifest.core.references.length} references, ${bundled.length} bundled skills)`,
+  );
+}
+
+syncSkills();