@kaydash9999/banker-plugins 0.23.3 → 0.24.0

package/skills/build-testbox/scripts/args.mjs

@@ -0,0 +1,156 @@
+// Argument parsing for build-testbox (detect, run, setup). A bad argument throws UsageError (exit 2).
+import { existsSync, statSync } from "node:fs";
+import { cpus } from "node:os";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+export class UsageError extends Error {}
+
+export const BROWSERS = ["chromium", "webkit"];
+export const DEFAULT_IMAGES = { rocky8: "docker.io/rockylinux/rockylinux:8", rocky9: "docker.io/rockylinux/rockylinux:9" };
+const OS_NAME = /^[a-z][a-z0-9-]{0,30}$/;
+const IMAGE = /^[A-Za-z0-9][A-Za-z0-9._/:@-]{0,254}$/;
+const VM_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+const LOOPBACK = new Set(["localhost", "127.0.0.1", "[::1]"]);
+
+const list = (v) => String(v).split(",").map((s) => s.trim()).filter(Boolean);
+
+function intIn(flag, v, lo, hi) {
+  const n = Number(v);
+  if (!Number.isInteger(n) || n < lo || n > hi) throw new UsageError(`${flag} 는 ${lo}~${hi} 정수입니다: ${v}`);
+  return n;
+}
+
+function oneOf(flag, v, allowed) {
+  if (!allowed.includes(v)) throw new UsageError(`${flag} 는 ${allowed.join(", ")} 중 하나입니다: ${v}`);
+  return v;
+}
+
+function browsersOf(v) {
+  const names = list(v);
+  for (const n of names) oneOf("--browsers", n, BROWSERS);
+  if (!names.length) throw new UsageError("--browsers 가 비었습니다");
+  return [...new Set(names)];
+}
+
+function osOf(v) {
+  if (v === "none") return [];
+  const names = list(v);
+  for (const n of names) if (!OS_NAME.test(n)) throw new UsageError(`--os 이름은 영문 소문자, 숫자, - 입니다: ${n}`);
+  if (!names.length) throw new UsageError("--os 가 비었습니다(컨테이너 묶음을 빼려면 --os none)");
+  return [...new Set(names)];
+}
+
+function imageOf(o, v) {
+  const at = String(v).indexOf("=");
+  const name = at > 0 ? v.slice(0, at) : "";
+  const image = at > 0 ? v.slice(at + 1) : "";
+  if (!OS_NAME.test(name) || !IMAGE.test(image)) throw new UsageError(`--image 는 <os>=<이미지> 입니다: ${v}`);
+  o.images[name] = image;
+}
+
+function devicesOf(v) {
+  const names = list(v);
+  if (!names.length) throw new UsageError("--devices 가 비었습니다");
+  if (new Set(names).size !== names.length) throw new UsageError("--devices 에 같은 기기가 둘 이상입니다");
+  return names;
+}
+
+function httpUrl(target, allowRemote) {
+  let url;
+  try { url = new URL(target); } catch { throw new UsageError(`URL 이 아닙니다: ${target}`); }
+  if (!allowRemote && !LOOPBACK.has(url.hostname)) throw new UsageError(`loopback 이 아닌 주소는 --allow-remote 를 줄 때만 엽니다: ${target}`);
+  return url.href;
+}
+
+// --url: an http(s) URL (loopback unless --allow-remote) or an existing local file.
+export function toUrl(target, allowRemote = false, cwd = process.cwd()) {
+  if (/^https?:\/\//i.test(target)) return httpUrl(target, allowRemote);
+  if (/^[\\/]{2}/.test(target)) throw new UsageError(`네트워크 경로는 열지 않습니다: ${target}`);
+  if (/^[A-Za-z][A-Za-z0-9+.-]+:/.test(target) && !/^[A-Za-z]:[\\/]/.test(target)) throw new UsageError(`http, https URL 이나 로컬 파일만 엽니다: ${target}`);
+  const file = resolve(cwd, target);
+  if (!existsSync(file) || !statSync(file).isFile()) throw new UsageError(`파일이 없습니다: ${file}`);
+  return pathToFileURL(file).href;
+}
+
+const VALUES = {
+  "--url": (o, v) => { o.urlArg = v; },
+  "--browsers": (o, v) => { o.browsers = browsersOf(v); o.browsersGiven = true; },
+  "--devices": (o, v) => { o.devices = devicesOf(v); },
+  "--os": (o, v) => { o.os = osOf(v); },
+  "--image": imageOf,
+  "--cmd": (o, v) => { if (!String(v).trim()) throw new UsageError("--cmd 가 비었습니다"); o.cmd = v; },
+  "--src": (o, v) => { o.src = resolve(v); },
+  "--engine": (o, v) => { o.engine = oneOf("--engine", v, ["auto", "docker", "podman"]); },
+  "--network": (o, v) => { o.network = oneOf("--network", v, ["bridge", "none", "host"]); },
+  "--jobs": (o, v) => { o.jobs = intIn("--jobs", v, 1, 64); },
+  "--timeout": (o, v) => { o.timeout = intIn("--timeout", v, 1, 86400); },
+  "--out": (o, v) => { o.out = resolve(v); },
+  "--tart-vm": (o, v) => { if (!VM_NAME.test(v)) throw new UsageError(`--tart-vm 이름이 맞지 않습니다: ${v}`); o.tartVm = v; },
+  "--images": (o, v) => { o.setupImages = osOf(v); },
+  "--playwright-dir": (o, v) => { if (!String(v).trim()) throw new UsageError("--playwright-dir 가 비었습니다"); o.playwrightDir = resolve(v); },
+};
+
+const SWITCHES = {
+  "--json": "json", "--yes": "yes", "--browser-in-container": "browserInContainer", "--playwright-image": "playwrightImage",
+  "--playwright-from-project": "fromProject", "--allow-remote": "allowRemote",
+};
+
+const ALLOWED = {
+  detect: ["--json", "--engine", "--image", "--os", "--playwright-from-project", "--playwright-dir"],
+  run: ["--url", "--browsers", "--devices", "--browser-in-container", "--os", "--image", "--cmd", "--src", "--engine",
+    "--network", "--jobs", "--timeout", "--out", "--playwright-from-project", "--playwright-dir", "--allow-remote", "--tart-vm", "--json"],
+  setup: ["--images", "--browsers", "--playwright-image", "--yes", "--engine", "--image", "--playwright-from-project", "--playwright-dir", "--json"],
+};
+
+function defaults(command) {
+  return {
+    command, json: false, yes: false, browserInContainer: false, playwrightImage: false, fromProject: false, playwrightDir: null, allowRemote: false,
+    urlArg: null, url: null, browsers: [...BROWSERS], browsersGiven: false, devices: null, os: ["rocky8", "rocky9"], images: {},
+    cmd: "cat /etc/os-release", src: process.cwd(), engine: "auto", network: null,
+    jobs: Math.max(1, Math.min(4, cpus().length || 1)), timeout: 300, out: null, tartVm: null, setupImages: null,
+  };
+}
+
+function readFlags(command, argv) {
+  const o = defaults(command);
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (!ALLOWED[command].includes(a)) throw new UsageError(`${command} 에 쓸 수 없는 인자입니다: ${a}`);
+    if (SWITCHES[a]) { o[SWITCHES[a]] = true; continue; }
+    if (argv[i + 1] === undefined) throw new UsageError(`${a} 뒤에 값이 필요합니다`);
+    VALUES[a](o, argv[++i]);
+  }
+  return o;
+}
+
+export const imageFor = (o, os) => o.images[os] || DEFAULT_IMAGES[os] || null;
+
+function validateBrowserArgs(o) {
+  const browserOnly = o.devices || o.browsersGiven || o.browserInContainer;
+  if (!o.urlArg && browserOnly) throw new UsageError("--devices, --browsers, --browser-in-container 는 --url 과 함께 씁니다");
+  if (o.urlArg) o.url = toUrl(o.urlArg, o.allowRemote);
+  if (o.browserInContainer && !/^https?:/.test(o.url)) throw new UsageError("--browser-in-container 는 http, https URL 만 엽니다");
+}
+
+function validateRun(o) {
+  validateBrowserArgs(o);
+  const noImage = o.os.find((os) => os !== "macos" && !imageFor(o, os));
+  if (noImage) throw new UsageError(`--os ${noImage} 의 이미지를 --image ${noImage}=<이미지> 로 주십시오`);
+  if (!o.url && !o.os.length) throw new UsageError("돌릴 칸이 없습니다(--url 과 --os 가 모두 비었음)");
+  return o;
+}
+
+function validateSetup(o) {
+  for (const os of o.setupImages || []) if (os === "macos" || !imageFor(o, os)) throw new UsageError(`--images ${os} 는 받을 이미지가 없습니다(macOS 는 Tart 로 따로)`);
+  return o;
+}
+
+export function parseArgs(argv) {
+  const [command, ...rest] = argv;
+  if (!ALLOWED[command]) throw new UsageError(`하위 명령은 detect, run, setup 중 하나입니다: ${command ?? "(없음)"}`);
+  const o = readFlags(command, rest);
+  if (command === "run") return validateRun(o);
+  if (command === "setup") return validateSetup(o);
+  return o;
+}

package/skills/build-testbox/scripts/browser-cell.mjs

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+// Browser cells of build-testbox. Runs on the host (a child of testbox.mjs) or inside the Playwright image
+// (--browser-in-container), so it imports no other file of this skill. Each browser type starts once; each device
+// gets its own context. A cell passes when the response is 2xx or 3xx (a file URL has none) and the page threw nothing.
+//
+//   node browser-cell.mjs --playwright <playwright entry file> --spec <spec.json>
+//
+// spec: { url, jobs, timeoutMs, settleMs, outDir, cells: [{ id, device, browser, png }] }
+// Prints one line "BANKER_TESTBOX_RESULT <json>": { cells: [...] } or { fatal, detail }.
+import { mkdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+export const RESULT_TAG = "BANKER_TESTBOX_RESULT ";
+
+const firstLine = (e) => String((e && e.message) || e || "").split(/\r?\n/).map((l) => l.trim()).find(Boolean) || "";
+
+export function classifyLaunchError(message) {
+  const m = String(message || "");
+  if (/Executable doesn't exist/i.test(m)) return "needs-browser";
+  if (/missing dependencies|error while loading shared libraries|cannot open shared object file/i.test(m)) return "host-deps";
+  if (/\bEPERM\b|\bEACCES\b|Operation not permitted|Permission denied/i.test(m)) return "sandbox";
+  if (/Timeout \d+ms exceeded|timed out/i.test(m)) return "timeout";
+  return "launch-failed";
+}
+
+// chromium: Playwright's headless shell first, then the full Chromium (channel "chromium"); webkit has one build.
+const VARIANTS = {
+  chromium: [["headless-shell", {}], ["chromium", { channel: "chromium" }]],
+  webkit: [["webkit", {}]],
+};
+
+async function tryLaunch(pw, name, options, timeoutMs) {
+  try {
+    return { browser: await pw[name].launch({ ...options, timeout: timeoutMs }) };
+  } catch (e) {
+    const message = String((e && e.message) || e);
+    return { reason: classifyLaunchError(message), detail: firstLine(message).slice(0, 300) };
+  }
+}
+
+// The reason to report when no variant starts: a missing executable says less than a missing library.
+// No variant at all means the browser name is unknown.
+function worstReason(failures, name) {
+  if (!failures.length) return { reason: "launch-failed", detail: `모르는 브라우저 ${name}` };
+  const telling = failures.find((f) => f.reason !== "needs-browser");
+  return telling || failures[0];
+}
+
+// { browser, variant } or { reason, detail }.
+async function launchBest(pw, name, timeoutMs = 30000) {
+  const failures = [];
+  for (const [variant, options] of VARIANTS[name] || []) {
+    const r = await tryLaunch(pw, name, options, timeoutMs);
+    if (r.browser) return { browser: r.browser, variant };
+    failures.push({ ...r, variant });
+  }
+  return worstReason(failures, name);
+}
+
+// detect: each variant started and closed. { runnable, variant, reason, detail, variants: { <v>: { ok, reason?, detail? } } }
+export async function probeBrowser(pw, name, timeoutMs = 30000) {
+  const variants = {};
+  for (const [variant, options] of VARIANTS[name] || []) {
+    const r = await tryLaunch(pw, name, options, timeoutMs);
+    if (r.browser) await r.browser.close().catch(() => {});
+    variants[variant] = r.browser ? { ok: true } : { ok: false, reason: r.reason, detail: r.detail };
+  }
+  const ok = Object.entries(variants).find(([, v]) => v.ok);
+  if (ok) return { runnable: true, variant: ok[0], variants };
+  const worst = worstReason(Object.values(variants), name);
+  return { runnable: false, reason: worst.reason, detail: worst.detail, variants };
+}
+
+export function judge(httpStatus, pageErrors) {
+  if (httpStatus !== null && (httpStatus < 200 || httpStatus >= 400)) return ["fail", `http-${httpStatus}`];
+  if (pageErrors > 0) return ["fail", "page-error"];
+  return ["pass", ""];
+}
+
+async function visit(browser, pw, cell, spec) {
+  const context = await browser.newContext({ ...pw.devices[cell.device] });
+  const pageErrors = [];
+  const consoleErrors = [];
+  try {
+    const page = await context.newPage();
+    page.on("pageerror", (e) => pageErrors.push(firstLine(e).slice(0, 300)));
+    page.on("console", (m) => { if (m.type() === "error") consoleErrors.push(m.text().slice(0, 300)); });
+    const response = await page.goto(spec.url, { waitUntil: "load", timeout: spec.timeoutMs });
+    if (spec.settleMs) await page.waitForTimeout(spec.settleMs);
+    const title = await page.title();
+    await page.screenshot({ path: join(spec.outDir, cell.png) });
+    const httpStatus = response ? response.status() : null;
+    const [status, reason] = judge(httpStatus, pageErrors.length);
+    return { status, reason, httpStatus, title, pageErrors, consoleErrors, screenshot: cell.png };
+  } finally {
+    await context.close().catch(() => {});
+  }
+}
+
+async function runCell(browser, pw, cell, spec, variant) {
+  const startedAt = new Date().toISOString();
+  let timer;
+  const limit = new Promise((r) => { timer = setTimeout(() => r({ status: "unverified", reason: "timeout" }), spec.timeoutMs + 5000); });
+  let result;
+  try {
+    result = await Promise.race([visit(browser, pw, cell, spec), limit]);
+  } catch (e) {
+    const timeout = /Timeout \d+ms exceeded/i.test(String(e && e.message));
+    result = { status: timeout ? "unverified" : "fail", reason: timeout ? "timeout" : "page-error", detail: firstLine(e).slice(0, 300) };
+  } finally {
+    clearTimeout(timer);
+  }
+  return { id: cell.id, variant, ...result, startedAt, endedAt: new Date().toISOString() };
+}
+
+export async function pool(items, jobs, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const i = next++;
+      results[i] = await fn(items[i]);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.max(1, Math.min(jobs, items.length)) }, worker));
+  return results;
+}
+
+async function runBrowser(pw, name, cells, spec) {
+  const startedAt = new Date().toISOString();
+  const launched = await launchBest(pw, name, Math.min(spec.timeoutMs, 60000));
+  if (!launched.browser) {
+    const endedAt = new Date().toISOString();
+    return cells.map((c) => ({ id: c.id, status: "unverified", reason: launched.reason, detail: launched.detail, startedAt, endedAt }));
+  }
+  try {
+    return await pool(cells, spec.jobs || 1, (c) => runCell(launched.browser, pw, c, spec, launched.variant));
+  } finally {
+    await launched.browser.close().catch(() => {});
+  }
+}
+
+// All browser types at once; the cells of one type share its jobs.
+async function runGroup(pw, spec) {
+  mkdirSync(spec.outDir, { recursive: true });
+  const byBrowser = new Map();
+  for (const c of spec.cells) byBrowser.set(c.browser, [...(byBrowser.get(c.browser) || []), c]);
+  const groups = await Promise.all([...byBrowser].map(([name, cells]) => runBrowser(pw, name, cells, spec)));
+  return groups.flat();
+}
+
+export async function importPlaywright(entry) {
+  const mod = await import(pathToFileURL(entry).href);
+  return mod.chromium ? mod : mod.default;
+}
+
+function argOf(argv, flag) {
+  const i = argv.indexOf(flag);
+  return i >= 0 ? argv[i + 1] : undefined;
+}
+
+async function main(argv) {
+  const entry = argOf(argv, "--playwright");
+  const specFile = argOf(argv, "--spec");
+  let pw;
+  try {
+    pw = await importPlaywright(entry);
+  } catch (e) {
+    return { fatal: "needs-playwright", detail: firstLine(e) };
+  }
+  const spec = JSON.parse(readFileSync(specFile, "utf8"));
+  return { cells: await runGroup(pw, spec) };
+}
+
+const isMain = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  main(process.argv.slice(2))
+    .then((r) => { process.stdout.write(`${RESULT_TAG}${JSON.stringify(r)}\n`); process.exit(0); })
+    .catch((e) => { process.stdout.write(`${RESULT_TAG}${JSON.stringify({ fatal: "launch-failed", detail: firstLine(e) })}\n`); process.exit(0); });
+}

package/skills/build-testbox/scripts/browsers.mjs

@@ -0,0 +1,164 @@
+// The browser group of build-testbox: plans one cell per device and runs browser-cell.mjs on the host (a child
+// process) or inside the Playwright image (--browser-in-container). Downloads nothing.
+import { copyFileSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { BROWSERS, UsageError } from "./args.mjs";
+import { RESULT_TAG } from "./browser-cell.mjs";
+import { NAME_PREFIX, engineReason, imageState, randomTag, rmArgs } from "./containers.mjs";
+import { playwrightImage } from "./detect.mjs";
+import { firstLine, runProc } from "./proc.mjs";
+import { cellOf } from "./report.mjs";
+
+const CELL_SCRIPT = join(dirname(fileURLToPath(import.meta.url)), "browser-cell.mjs");
+export const DEFAULT_DEVICES = ["Desktop Chrome", "Pixel 7", "Desktop Safari", "iPhone 15"];
+const KNOWN = { "Desktop Chrome": "chromium", "Pixel 7": "chromium", "Desktop Safari": "webkit", "iPhone 15": "webkit" };
+const iso = () => new Date().toISOString();
+
+export const slug = (device) => device.replace(/[^A-Za-z0-9]+/g, "-").replace(/^-|-$/g, "").toLowerCase() || "device";
+
+function cellBase(device, browser) {
+  return { id: `browser:${device}`, group: "browser", target: device, device, browser, png: `browser-${slug(device)}.png` };
+}
+
+// One cell per device; the browser is the device's defaultBrowserType. devices is playwright.devices, or null when
+// Playwright is missing (then the four default names map by a fixed table and every cell is needs-playwright).
+// A cell with a preset reason does not run.
+function deviceCell(o, name, devices) {
+  if (!devices) {
+    const browser = KNOWN[name] || "?";
+    return browser !== "?" && !o.browsers.includes(browser) ? null : { ...cellBase(name, browser), preset: "needs-playwright" };
+  }
+  const d = devices[name];
+  if (!d) return { ...cellBase(name, KNOWN[name] || "?"), preset: "unknown-device" };
+  const browser = d.defaultBrowserType;
+  if (!BROWSERS.includes(browser)) throw new UsageError(`기기 ${name} 의 브라우저 ${browser} 는 지원하지 않습니다(chromium, webkit 만)`);
+  return o.browsers.includes(browser) ? cellBase(name, browser) : null;
+}
+
+export function planBrowserCells(o, devices) {
+  const cells = (o.devices || DEFAULT_DEVICES).map((name) => deviceCell(o, name, devices)).filter(Boolean);
+  if (!cells.length) throw new UsageError("--browsers 로 거르고 나니 브라우저 칸이 없습니다");
+  return cells;
+}
+
+const strip = ({ preset, ...rest }) => rest;
+
+function presetCell(c, detail) {
+  return cellOf({ ...strip(c), startedAt: iso() }, "unverified", c.preset, detail ? { detail } : {});
+}
+
+export function parseResult(text) {
+  const line = String(text).split(/\r?\n/).reverse().find((l) => l.startsWith(RESULT_TAG));
+  if (!line) return null;
+  try { return JSON.parse(line.slice(RESULT_TAG.length)); } catch { return null; }
+}
+
+// Child results joined to the planned cells. A cell the child never reported is timeout (child killed) or
+// launch-failed.
+export function mergeResults(cells, r, extra) {
+  const parsed = parseResult(r.stdout);
+  const byId = new Map(((parsed && parsed.cells) || []).map((c) => [c.id, c]));
+  return cells.map((c) => {
+    const got = byId.get(c.id);
+    const base = { ...strip(c), ...extra };
+    if (got) return cellOf({ ...base, ...got, screenshot: got.screenshot ? join(extra.out, got.screenshot) : undefined }, got.status, got.reason);
+    if (parsed && parsed.fatal) return cellOf({ ...base, startedAt: iso() }, "unverified", parsed.fatal, { detail: parsed.detail });
+    return cellOf({ ...base, startedAt: iso() }, "unverified", r.timedOut ? "timeout" : "launch-failed", { detail: (r.stderr || r.error || "").slice(0, 300) });
+  });
+}
+
+const groupLimit = (o, n) => (o.timeout * Math.ceil(n / o.jobs) + 90) * 1000;
+
+function specOf(o, cells, outDir, url) {
+  return { url, jobs: o.jobs, timeoutMs: o.timeout * 1000, settleMs: 300, outDir, cells: cells.map(({ id, device, browser, png }) => ({ id, device, browser, png })) };
+}
+
+async function runOnHost(ctx, cells) {
+  const { o, out } = ctx;
+  const specFile = join(out, "browser-spec.json");
+  writeFileSync(specFile, JSON.stringify(specOf(o, cells, out, o.url)));
+  const r = await runProc(process.execPath, [CELL_SCRIPT, "--playwright", ctx.pwInfo.entry, "--spec", specFile], { cwd: out, timeoutMs: groupLimit(o, cells.length) });
+  const log = join(out, "browser.log");
+  writeFileSync(log, r.out);
+  return mergeResults(cells, r, { out, log, where: "host" });
+}
+
+// Inside a container the host's loopback is the container's on Linux with --network host; elsewhere the engine's
+// host name stands in for it.
+export function containerUrl(url, engine, platform = process.platform) {
+  if (platform === "linux") return url;
+  const u = new URL(url);
+  if (["localhost", "127.0.0.1", "[::1]"].includes(u.hostname)) u.hostname = engine.kind === "podman" ? "host.containers.internal" : "host.docker.internal";
+  return u.href;
+}
+
+function stageRunner(o, cells, url) {
+  const dir = mkdtempSync(join(tmpdir(), `${NAME_PREFIX}-pw-`));
+  mkdirSync(join(dir, "node_modules"));
+  copyFileSync(CELL_SCRIPT, join(dir, "browser-cell.mjs"));
+  writeFileSync(join(dir, "spec.json"), JSON.stringify(specOf(o, cells, "/tb/out", url)));
+  return dir;
+}
+
+// The cp steps: the runner and spec, then the host's playwright package and the playwright-core it depends on.
+export function copySteps(stageDir, pwInfo, name) {
+  return [
+    ["cp", `${stageDir}${sep}.`, `${name}:/tb`],
+    ["cp", pwInfo.dir, `${name}:/tb/node_modules/playwright`],
+    ["cp", pwInfo.coreDir, `${name}:/tb/node_modules/playwright-core`],
+  ];
+}
+
+async function containerSteps(ctx, cells, name, stageDir) {
+  const { o, engine, out } = ctx;
+  const linux = process.platform === "linux";
+  const runner = ["node", "/tb/browser-cell.mjs", "--playwright", "/tb/node_modules/playwright/index.mjs", "--spec", "/tb/spec.json"];
+  const create = ["create", "--name", name, "--ipc=host", ...(linux ? ["--network", "host"] : []), ctx.image, ...runner];
+  for (const args of [create, ...copySteps(stageDir, ctx.pwInfo, name)]) {
+    const r = await runProc(engine.bin, args, { timeoutMs: 600000 });
+    if (r.code !== 0) return { failed: r };
+  }
+  const r = await runProc(engine.bin, ["start", "-a", name], { timeoutMs: groupLimit(o, cells.length) });
+  await runProc(engine.bin, ["cp", `${name}:/tb/out/.`, out], { timeoutMs: 600000 });
+  return { r, network: linux ? "host" : "default" };
+}
+
+async function runInContainer(ctx, cells) {
+  const { engine, out } = ctx;
+  if (!engine) return cells.map((c) => presetCell({ ...c, preset: "needs-engine" }));
+  ctx.image = ctx.o.images.playwright || playwrightImage(ctx.pwInfo.version);
+  const img = await imageState(engine, ctx.image);
+  if (!img.present) return cells.map((c) => presetCell({ ...c, preset: img.reason, image: ctx.image }, img.detail));
+  const name = `${NAME_PREFIX}-${randomTag()}-browser`;
+  const stageDir = stageRunner(ctx.o, cells, containerUrl(ctx.o.url, engine));
+  ctx.tracker.containers.add(name);
+  ctx.tracker.temps.add(stageDir);
+  try {
+    const s = await containerSteps(ctx, cells, name, stageDir);
+    const log = join(out, "browser.log");
+    writeFileSync(log, (s.failed || s.r).out);
+    if (s.failed) {
+      const reason = engineReason(`${s.failed.out}\n${s.failed.error || ""}`) || "launch-failed";
+      return cells.map((c) => presetCell({ ...c, preset: reason, image: ctx.image, log }, firstLine(s.failed.stderr) || s.failed.error));
+    }
+    return mergeResults(cells, s.r, { out, log, where: "container", image: ctx.image, network: s.network, engine: engine.name });
+  } finally {
+    await runProc(engine.bin, rmArgs(engine, name), { timeoutMs: 60000 });
+    rmSync(stageDir, { recursive: true, force: true });
+    ctx.tracker.containers.delete(name);
+    ctx.tracker.temps.delete(stageDir);
+  }
+}
+
+// ctx: { o, out, engine, tracker, pw, pwInfo, pwError }
+export async function runBrowserGroup(ctx) {
+  const cells = planBrowserCells(ctx.o, ctx.pw ? ctx.pw.devices : null);
+  const preset = cells.filter((c) => c.preset).map((c) => presetCell(c, c.preset === "needs-playwright" ? ctx.pwError : null));
+  const live = cells.filter((c) => !c.preset);
+  if (!live.length) return preset;
+  const ran = ctx.o.browserInContainer ? await runInContainer(ctx, live) : await runOnHost(ctx, live);
+  const order = new Map(cells.map((c, i) => [c.id, i]));
+  return [...preset, ...ran].sort((a, b) => order.get(a.id) - order.get(b.id));
+}