@beryl-so/cli 0.73.2 → 0.78.0

package/dist/commands/init.js

@@ -6,31 +6,22 @@ import { BERYL_COPILOT_MARK_BEGIN, BERYL_COPILOT_MARK_END, BERYL_COPILOT_SECTION
 import { loadConfig } from "../config.js";
 import { AuthError, CliError, UsageError } from "../errors.js";
 import { ApiClient } from "../http.js";
-import { bold, cyan, dim, green, red, yellow } from "../output.js";
-import { anyGap, describeGaps, installCommandsFor, installPlaywright, playwrightGaps, } from "../playwright-install.js";
+import { bold, cyan, dim, green, yellow } from "../output.js";
 import { aliasMachineToAccount, captureCliEvent, flushTelemetry, shutdownTelemetry, } from "../telemetry.js";
 import { cliVersion, warnIfStale } from "../version-check.js";
 import { authCommands } from "./auth.js";
 import { flagStr } from "./util.js";
-// Pinned to @latest (like the Playwright entry below) — an unpinned spec lets npx
-// serve whatever stale global/cache install already resolves, so the agent's MCP
-// server would silently miss newer tools. mergeMcpConfig compares entries verbatim,
-// so re-running init also upgrades an old unpinned entry in place.
+// Pinned to @latest: an unpinned spec lets npx serve whatever stale global/cache
+// install already resolves, so the agent's MCP server would silently miss newer tools.
+// mergeMcpConfig compares entries verbatim, so re-running init also upgrades an old
+// unpinned entry in place.
 const MCP_SERVER_ENTRY = {
     command: "npx",
     args: ["-y", "@beryl-so/cli@latest", "mcp"],
 };
-// Headless: the coding agent drives this browser to set up sign-ins and repair plans; nobody
-// watches the window, and a headed default breaks on CI / headless boxes. Matches how most devs
-// already wire their own user-scoped playwright.
-const PLAYWRIGHT_SERVER_ENTRY = {
-    command: "npx",
-    args: ["@playwright/mcp@latest", "--headless"],
-};
 // VS Code's `.vscode/mcp.json` uses a top-level `servers` key and tags each stdio server
-// with `type`, unlike Cursor/Claude's `mcpServers`. Same pinned commands, different shape.
+// with `type`, unlike Cursor/Claude's `mcpServers`. Same pinned command, different shape.
 const VSCODE_MCP_SERVER_ENTRY = { type: "stdio", ...MCP_SERVER_ENTRY };
-const VSCODE_PLAYWRIGHT_SERVER_ENTRY = { type: "stdio", ...PLAYWRIGHT_SERVER_ENTRY };
 // opencode flattens command + args into one array under `mcp`.
 function opencodeEntry(entry) {
     return { type: "local", command: [entry.command, ...entry.args], enabled: true };
@@ -45,14 +36,14 @@ function snippetEntry(name, entry) {
 const MANUAL_CONFIG_SNIPPET = [
     "    {",
     '      "mcpServers": {',
-    `${snippetEntry("beryl", MCP_SERVER_ENTRY)},`,
-    snippetEntry("playwright", PLAYWRIGHT_SERVER_ENTRY),
+    snippetEntry("beryl", MCP_SERVER_ENTRY),
     "      }",
     "    }",
 ].join("\n");
 // `key` is the container the editor expects: `mcpServers` for Claude/Cursor, `servers` for
-// VS Code, `mcp` for opencode. `entries` are the editor-shaped server objects.
-function mergeMcpConfig(file, key, entries) {
+// VS Code, `mcp` for opencode. Only the beryl entry is ours; every other server (including
+// a user-wired playwright) is left untouched.
+function mergeMcpConfig(file, key, entry) {
     let existing = {};
     if (fs.existsSync(file)) {
         try {
@@ -63,19 +54,14 @@ function mergeMcpConfig(file, key, entries) {
         }
     }
     const servers = (existing[key] ?? {});
-    const beryl = JSON.stringify(servers.beryl) !== JSON.stringify(entries.beryl);
-    if (beryl)
-        servers.beryl = entries.beryl;
-    // Never clobber a playwright server the user already wired up.
-    const playwright = servers.playwright === undefined;
-    if (playwright)
-        servers.playwright = entries.playwright;
-    if (beryl || playwright) {
+    const beryl = JSON.stringify(servers.beryl) !== JSON.stringify(entry);
+    if (beryl) {
+        servers.beryl = entry;
         existing[key] = servers;
         fs.mkdirSync(path.dirname(file), { recursive: true });
         fs.writeFileSync(file, JSON.stringify(existing, null, 2) + "\n");
     }
-    return { beryl, playwright };
+    return { beryl };
 }
 function claudeUserAdd(name, entry) {
     try {
@@ -230,32 +216,6 @@ export function refreshInstalledSkills(cwd) {
     }
     return refreshed;
 }
-// Local runs drive a real browser, so the install is mandatory, not offered:
-// missing means install now, no prompt, no opt-out. The runner ships with the CLI; the
-// browser is the per-machine half, fetched for the runner's own revision. Never throws — a
-// failed install must not fail `init`, which has already done its wiring; it prints the
-// exact commands instead.
-async function ensureLocalPlaywright(ctx, cwd) {
-    const gaps = playwrightGaps(cwd);
-    if (!anyGap(gaps)) {
-        ctx.err(`${green("✓")} Playwright + Chromium already installed ${dim("(local runs ready)")}`);
-        return;
-    }
-    try {
-        await installPlaywright(cwd, (line) => ctx.err(dim(line)));
-        // Believe the check, not the exit code — "local runs ready" is only honest if both
-        // halves are actually there afterwards.
-        const left = playwrightGaps(cwd);
-        if (anyGap(left))
-            throw new Error(`${describeGaps(left)} still missing afterwards`);
-        ctx.err(`${green("✓")} ${describeGaps(gaps)} installed ${dim("(local runs ready)")}`);
-    }
-    catch (err) {
-        ctx.err(`${red("✗")} Playwright install failed: ${err.message}`);
-        ctx.err(`${dim("•")} Finish the install by hand; local runs need it:\n` +
-            `    ${cyan(installCommandsFor(gaps, cwd))}`);
-    }
-}
 const CLIENTS = [
     ["claude", "Claude Code + Claude desktop app"],
     ["cursor", "Cursor"],
@@ -290,8 +250,8 @@ export const initCommands = [
     {
         name: "init",
         summary: "Set up Beryl in this repo: sign in and wire up your coding agent",
-        description: "Signs you in, wires the beryl and playwright MCP servers into the coding agent you " +
-            "pick, writes the beryl-test skill, and installs Chromium if it is missing. " +
+        description: "Signs you in, wires the beryl MCP server into the coding agent you pick, and writes " +
+            "the beryl-test skill. " +
             "Pick an agent with --claude, --cursor, --vscode and/or --opencode. With no flag it " +
             "prompts (Enter picks Claude); with no flag and no TTY it wires nothing and prints the " +
             "flags. --claude also wires the Claude DESKTOP app when installed, which needs a quit " +
@@ -394,51 +354,35 @@ export const initCommands = [
             if (clients.has("claude") && scope === "user") {
                 // Claude Code owns ~/.claude.json — shell out to `claude mcp add` rather than write it.
                 const beryl = claudeUserAdd("beryl", MCP_SERVER_ENTRY);
-                const playwright = claudeUserAdd("playwright", PLAYWRIGHT_SERVER_ENTRY);
-                if (beryl.ok && playwright.ok) {
-                    ctx.err(`${green("✓")} beryl + playwright MCP configured ${dim("(user scope)")}`);
+                if (beryl.ok) {
+                    ctx.err(`${green("✓")} beryl MCP configured ${dim("(user scope)")}`);
                 }
                 else {
-                    const failure = [beryl, playwright].find((r) => !r.ok && r.reason === "failed");
-                    ctx.err(yellow(failure
-                        ? `• \`claude mcp add\` failed (${failure.detail}); run these to wire user-scope MCP servers:`
-                        : "• `claude` not on PATH; run these to wire user-scope MCP servers:"));
+                    ctx.err(yellow(beryl.reason === "failed"
+                        ? `• \`claude mcp add\` failed (${beryl.detail}); run this to wire the user-scope MCP server:`
+                        : "• `claude` not on PATH; run this to wire the user-scope MCP server:"));
                     ctx.err(`    ${cyan(claudeAddHint("beryl", MCP_SERVER_ENTRY))}`);
-                    ctx.err(`    ${cyan(claudeAddHint("playwright", PLAYWRIGHT_SERVER_ENTRY))}`);
                 }
             }
             else if (clients.has("claude")) {
                 const file = path.join(cwd, ".mcp.json");
-                const wrote = mergeMcpConfig(file, "mcpServers", {
-                    beryl: MCP_SERVER_ENTRY,
-                    playwright: PLAYWRIGHT_SERVER_ENTRY,
-                });
-                const where = path.relative(cwd, file);
-                report("beryl MCP", wrote.beryl, where);
-                report("playwright MCP", wrote.playwright, where);
+                const wrote = mergeMcpConfig(file, "mcpServers", MCP_SERVER_ENTRY);
+                report("beryl MCP", wrote.beryl, path.relative(cwd, file));
             }
             // Separate surface from Claude Code, read only at launch.
             const desktopFile = clients.has("claude") && scope === "user" ? claudeDesktopConfigFile() : null;
             if (desktopFile) {
-                const wrote = mergeMcpConfig(desktopFile, "mcpServers", {
-                    beryl: MCP_SERVER_ENTRY,
-                    playwright: PLAYWRIGHT_SERVER_ENTRY,
-                });
+                const wrote = mergeMcpConfig(desktopFile, "mcpServers", MCP_SERVER_ENTRY);
                 report("Claude desktop beryl MCP", wrote.beryl, "(Claude desktop app)");
-                report("Claude desktop playwright MCP", wrote.playwright, "(Claude desktop app)");
-                if (wrote.beryl || wrote.playwright) {
+                if (wrote.beryl) {
                     ctx.err(yellow("• Quit and reopen Claude desktop: it reads that config at launch."));
                 }
             }
             if (clients.has("cursor")) {
                 const file = scope === "user" ? cursorUserConfigPath() : path.join(cwd, ".cursor", "mcp.json");
-                const wrote = mergeMcpConfig(file, "mcpServers", {
-                    beryl: MCP_SERVER_ENTRY,
-                    playwright: PLAYWRIGHT_SERVER_ENTRY,
-                });
+                const wrote = mergeMcpConfig(file, "mcpServers", MCP_SERVER_ENTRY);
                 const where = scope === "user" ? file : path.relative(cwd, file);
                 report("cursor beryl MCP", wrote.beryl, where);
-                report("cursor playwright MCP", wrote.playwright, where);
                 const rule = writeCursorRule(cwd);
                 ctx.err(`${green("✓")} cursor authoring rule ${outcomeLabel(rule.outcome)} ${dim(path.relative(cwd, rule.file))}`);
                 if (scope === "user") {
@@ -455,13 +399,9 @@ export const initCommands = [
                 const file = userDir
                     ? path.join(userDir, "mcp.json")
                     : path.join(cwd, ".vscode", "mcp.json");
-                const wrote = mergeMcpConfig(file, "servers", {
-                    beryl: VSCODE_MCP_SERVER_ENTRY,
-                    playwright: VSCODE_PLAYWRIGHT_SERVER_ENTRY,
-                });
+                const wrote = mergeMcpConfig(file, "servers", VSCODE_MCP_SERVER_ENTRY);
                 const where = userDir ? file : path.relative(cwd, file);
                 report("vscode beryl MCP", wrote.beryl, where);
-                report("vscode playwright MCP", wrote.playwright, where);
                 if (scope === "user" && !userDir) {
                     ctx.err(dim("  • VS Code's user config dir was not found, so this went to a repo-local " +
                         ".vscode/mcp.json. Run --vscode from your project, or add the server via " +
@@ -479,19 +419,14 @@ export const initCommands = [
                 const { file, jsonc } = opencodeConfigFile(scope, cwd);
                 if (jsonc) {
                     ctx.err(yellow(`• ${file} is JSONC and may hold comments, so it was left alone.`));
-                    ctx.err(cyan(`    Add these under "mcp": ${JSON.stringify({
+                    ctx.err(cyan(`    Add this under "mcp": ${JSON.stringify({
                         beryl: opencodeEntry(MCP_SERVER_ENTRY),
-                        playwright: opencodeEntry(PLAYWRIGHT_SERVER_ENTRY),
                     })}`));
                 }
                 else {
-                    const wrote = mergeMcpConfig(file, "mcp", {
-                        beryl: opencodeEntry(MCP_SERVER_ENTRY),
-                        playwright: opencodeEntry(PLAYWRIGHT_SERVER_ENTRY),
-                    });
+                    const wrote = mergeMcpConfig(file, "mcp", opencodeEntry(MCP_SERVER_ENTRY));
                     const where = scope === "user" ? file : path.relative(cwd, file);
                     report("opencode beryl MCP", wrote.beryl, where);
-                    report("opencode playwright MCP", wrote.playwright, where);
                 }
             }
             const skills = writeSkills(cwd, scope);
@@ -508,7 +443,6 @@ export const initCommands = [
                     : skillWhere;
                 ctx.err(`${green("✓")} beryl-test skill ${what} ${dim(where)}`);
             }
-            await ensureLocalPlaywright(ctx, cwd);
             // Name the agent actually wired, not the raw flag: the picker sets `clients` too.
             const ed = clients.has("claude")
                 ? { open: "open your editor", agent: "Claude" }
@@ -528,8 +462,8 @@ export const initCommands = [
                     `    ${yellow(`Details: ${MANUAL_SETUP_DOCS}`)}\n`
                 : `\n${bold(`Beryl is set up. Now ${ed.open} and ask ${ed.agent} to create tests.`)}\n` +
                     `  ${dim(`• Say: "create tests for https://example.com from docs/checkout.md" and ${ed.agent} starts`)}\n` +
-                    `  ${dim("  a cloud test-creation job that authors them from that document.")}\n` +
-                    `  ${dim(`• Then ask ${ed.agent} to run them on this machine (local runs) or in the cloud.`)}\n`;
+                    `  ${dim("  a cloud test-creation job (jobs create) that authors them from that document.")}\n` +
+                    `  ${dim(`• Then ask ${ed.agent} to run them in Beryl's cloud (runs trigger).`)}\n`;
             // The .mcp.json entry is pinned to @latest, but a global install / old npx cache
             // still wins resolution — so tell the user when the CLI they just ran is stale.
             await warnIfStale(cliVersion(), (msg) => ctx.err(yellow(msg)));
@@ -552,7 +486,7 @@ export const initCommands = [
         description: "The guide to durable, healable tests: where new tests come from (`jobs create`), the " +
             "ActionPlan shape, outcome assertions, natural-language intent, test accounts and the " +
             "project mailbox ({{login_email}}, {{mailbox_address}}, {{inbox_address}} + " +
-            "await_email), and the local run-fix loop. Same content as the beryl-test skill " +
+            "await_email), and the run-fix loop. Same content as the beryl-test skill " +
             "`beryl init` installs. " +
             `Skip if a loaded beryl-test skill states v${cliVersion()}; else call this first ` +
             "(works without logging in).",

package/dist/commands/jobs.js

@@ -29,6 +29,10 @@ export function jobHuman(job) {
         lines.push("Skipped scenarios:");
     for (const s of skipped)
         lines.push(`  ${s.handle}: ${s.reason}`);
+    for (const step of job.surface_steps ?? []) {
+        for (const w of step.warnings ?? [])
+            lines.push(`Warning [${step.surface}]: ${w}`);
+    }
     return lines.join("\n");
 }
 export const jobCommands = [

package/dist/commands/projects.js

@@ -94,16 +94,6 @@ export const projectCommands = [
                     "site, and only asked when detection is genuinely unsure",
             },
             { name: "force-new-login", type: "boolean", description: "Ignore any reusable saved login" },
-            {
-                name: "explore",
-                type: "boolean",
-                description: "Also start a cloud exploration that authors tests for you. Off by default: create " +
-                    "tests from a document with `beryl jobs create`",
-                mcpDescription: "Leave unset: create tests from a document with `jobs create`. Set only when the " +
-                    "user explicitly asks for a cloud exploration",
-            },
-            { name: "watch", type: "boolean", description: "Start the exploration (implies --explore) and stream it live" },
-            { name: "timeout", type: "number", description: "With --watch: max minutes to wait" },
         ],
         examples: [
             "beryl projects create https://app.example.com",
@@ -111,21 +101,15 @@ export const projectCommands = [
             'beryl projects create --name "Acme production"',
         ],
         async run(ctx, input) {
-            const watch = flagBool(input, "watch");
-            if (input.flags.explore === false && watch)
-                throw new UsageError("--no-explore cannot be combined with --watch");
-            const explore = flagBool(input, "explore") || watch;
             const ws = await ctx.requireWorkspace(input);
             const rawUrl = input.args.url;
             const url = typeof rawUrl === "string" ? rawUrl : "";
             const name = flagStr(input, "name");
-            // Name-only: create a real empty project (no URL, no exploration). Set a URL
-            // later with `beryl envs update <env-id>`.
+            // Name-only: create a real empty project (no URL). Set a URL later with
+            // `beryl envs update <env-id>`.
             if (!url) {
                 if (!name)
                     throw new UsageError("Provide a URL, or --name to create an empty project");
-                if (explore)
-                    throw new UsageError("--explore and --watch need a URL to explore");
                 const created = (await ctx.client.post(`/workspaces/${ws}/projects`, {
                     name,
                 }));
@@ -141,29 +125,12 @@ export const projectCommands = [
                 root_url: url,
                 requires_auth_choice: auth,
                 force_new_login: flagBool(input, "force-new-login"),
-                skip_exploration: !explore,
             }));
-            if (!explore)
-                return {
-                    data: created,
-                    human: `${green("Project created")}: ${created.project_id}\n` +
-                        `Create tests from a document describing the flows: \`beryl jobs create <file>\`.`,
-                };
-            // The agent cannot start until a login is captured, so there is nothing to watch.
-            if (created.auth_status === "needs_capture")
-                return {
-                    data: created,
-                    human: `${green("Project created")}: ${created.project_id}\n` +
-                        `The site needs a login before the agent can explore it. Capture one in the ` +
-                        `Beryl webapp (open the project — it walks you through the login) — the ` +
-                        `exploration starts as soon as you do.`,
-                };
-            if (!flagBool(input, "watch"))
-                return { data: created };
-            ctx.err(dim(`project ${created.project_id} created — waiting for the agent to start…`));
-            const explorationId = await pollCurrentExploration(ctx, ws, created.project_id);
-            const watched = await watchExploration(ctx, ws, created.project_id, explorationId, flagNum(input, "timeout"));
-            return { data: { ...created, ...watched.data }, exitCode: watched.exitCode };
+            return {
+                data: created,
+                human: `${green("Project created")}: ${created.project_id}\n` +
+                    `Create tests from a document describing the flows: \`beryl jobs create <file>\`.`,
+            };
         },
     },
     {
@@ -231,19 +198,26 @@ export const projectCommands = [
         name: "projects surfaces",
         summary: "Set which surfaces are enabled for this project",
         description: "Replaces the project's enabled surfaces with the ones listed: web-desktop, " +
-            "web-tablet, web-mobile. A new project has web-desktop only. At least one is " +
-            "required; `projects get` shows the current set. Turning a surface off removes " +
-            "no tests: delete a surface's tests to stop running them.",
+            "web-tablet, web-mobile, android, ios. A new project has web-desktop only. At least " +
+            "one is required; `projects get` shows the current set. Turning a surface off " +
+            "removes no tests: delete a surface's tests to stop running them. android and ios " +
+            "test the app named by each environment's app id for that surface (`envs update " +
+            "--app-id android=<package> --app-id ios=<bundle id>`) from its newest uploaded build " +
+            "(`config files upload app.apk`, `config files upload App.zip --kind ios_build`), on " +
+            "Beryl's Android and iOS workers.",
         scope: "project",
         args: [
             {
                 name: "surfaces",
-                description: "web-desktop | web-tablet | web-mobile, one or more",
+                description: "web-desktop | web-tablet | web-mobile | android | ios, one or more",
                 required: true,
                 variadic: true,
             },
         ],
-        examples: ["beryl projects surfaces web-desktop web-mobile", "beryl projects surfaces web-desktop"],
+        examples: [
+            "beryl projects surfaces web-desktop web-mobile",
+            "beryl projects surfaces web-desktop android ios",
+        ],
         async run(ctx, input) {
             const { workspaceId, projectId } = await ctx.requireProject(input);
             const data = (await ctx.client.patch(projectPath(workspaceId, projectId), {