@beryl-so/cli 0.67.0 → 0.77.1

package/dist/commands/jobs.js

@@ -0,0 +1,129 @@
+import fs from "node:fs";
+import path from "node:path";
+import { UsageError } from "../errors.js";
+import { arg, flagBool, flagStr, projectPath } from "./util.js";
+const jobsPath = (ws, p) => `${projectPath(ws, p)}/test-creation-jobs`;
+const LLM_NOTICE = "The document is sent to the LLM that drives the agent, so leave out anything you " +
+    "would not share with it.";
+function readDocument(file) {
+    try {
+        return new Uint8Array(fs.readFileSync(file));
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            throw new UsageError(`file not found: ${file}`);
+        throw new UsageError(`cannot read ${file} (${code ?? err.message})`);
+    }
+}
+export function jobHuman(job) {
+    const lines = [`Job ${job.id}: ${job.status}`];
+    if (job.error)
+        lines.push(`Error: ${job.error}`);
+    for (const t of job.tests)
+        lines.push(`  ${t.title ?? t.id} [${t.surface}] ${t.id}`);
+    if (!job.tests.length)
+        lines.push("  No tests yet.");
+    const skipped = job.skipped_flows ?? [];
+    if (skipped.length)
+        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 = [
+    {
+        name: "jobs create",
+        groupSummary: "Test-creation jobs: the cloud agent reads a document and authors tests from it.",
+        summary: "Create tests from a document (PRD, release notes) on Beryl's cloud",
+        description: "Uploads a document (Markdown, plain text, PDF or DOCX, or --text) and queues a " +
+            "job: the agent explores the environment, drafts one flow per scenario the document " +
+            "describes, and authors one test per enabled surface of the project. New tests get " +
+            "no groups. A job runs once; to run it again, use `jobs clone`. " +
+            LLM_NOTICE,
+        scope: "project",
+        args: [{ name: "file", description: "Path to the document" }],
+        flags: [
+            { name: "text", type: "string", description: "The document as text, instead of a file" },
+            {
+                name: "env",
+                type: "string",
+                description: "Environment id to explore (defaults to the project's default)",
+            },
+        ],
+        examples: ["beryl jobs create ./release-notes.md --env <env-id>"],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            const file = input.args.file;
+            const text = flagStr(input, "text");
+            if (Boolean(file) === Boolean(text)) {
+                throw new UsageError("pass a document file or --text, not both");
+            }
+            const form = new FormData();
+            if (file)
+                form.set("file", new Blob([readDocument(file)]), path.basename(file));
+            else
+                form.set("text", text);
+            const envId = flagStr(input, "env");
+            if (envId)
+                form.set("environment_id", envId);
+            const job = (await ctx.client.request("POST", jobsPath(workspaceId, projectId), {
+                form,
+            }));
+            return {
+                data: job,
+                human: `Job ${job.id} queued. Check it with \`beryl jobs get ${job.id}\`.`,
+            };
+        },
+    },
+    {
+        name: "jobs list",
+        summary: "List the project's test-creation jobs",
+        scope: "project",
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            return { data: await ctx.client.get(jobsPath(workspaceId, projectId)) };
+        },
+    },
+    {
+        name: "jobs get",
+        summary: "Show a job's status and the tests it created",
+        scope: "project",
+        args: [{ name: "job-id", description: "Job id", required: true }],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            const job = (await ctx.client.get(`${jobsPath(workspaceId, projectId)}/${arg(input, "job-id")}`));
+            return { data: job, human: jobHuman(job) };
+        },
+    },
+    {
+        name: "jobs clone",
+        summary: "Run a job again: queue a new job with the same document and environment",
+        description: LLM_NOTICE,
+        scope: "project",
+        args: [{ name: "job-id", description: "Job id to clone", required: true }],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            const job = (await ctx.client.post(`${jobsPath(workspaceId, projectId)}/${arg(input, "job-id")}/clone`));
+            return { data: job, human: `Job ${job.id} queued.` };
+        },
+    },
+    {
+        name: "jobs delete",
+        summary: "Delete a job; the flows and tests it created stay",
+        scope: "project",
+        args: [{ name: "job-id", description: "Job id", required: true }],
+        flags: [{ name: "force", type: "boolean", description: "Skip the confirmation prompt" }],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            const jobId = arg(input, "job-id");
+            await ctx.confirm(`Delete job ${jobId}? Its tests stay.`, flagBool(input, "force"));
+            await ctx.client.del(`${jobsPath(workspaceId, projectId)}/${jobId}`);
+            return { human: "Deleted." };
+        },
+    },
+];

package/dist/commands/projects.js

@@ -1,7 +1,7 @@
 import { detectAuthGating } from "../detect.js";
 import { UsageError } from "../errors.js";
 import { dim, green, table, timeAgo } from "../output.js";
-import { arg, flagBool, flagNum, flagStr, projectPath } from "./util.js";
+import { arg, argList, flagBool, flagNum, flagStr, projectPath } from "./util.js";
 import { pollCurrentExploration, watchExploration } from "./watch.js";
 // The API treats the auth choice as the visitor's answer and never infers it — a null
 // choice leaves the project waiting on a login capture that never comes — so resolve it
@@ -84,7 +84,7 @@ export const projectCommands = [
                 name: "name",
                 type: "string",
                 description: "Name for an empty project when no URL is given. Add a URL later with " +
-                    "`beryl envs update <env-id>`, or author tests over the CLI/MCP",
+                    "`beryl envs update <env-id>`",
             },
             {
                 name: "auth",
@@ -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: author " +
-                    "tests with `beryl tests create` or your coding agent over MCP",
-                mcpDescription: "Leave unset: you author the tests yourself with `tests 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,29 +101,23 @@ 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>` or author over the CLI/MCP.
+            // 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,
                 }));
                 return {
                     data: created,
                     human: `${green("Project created")}: ${created.project_id} ${dim("(empty)")}\n` +
-                        `Add a site with \`beryl envs update <env-id>\`, or author tests with ` +
-                        `\`beryl tests create\`.`,
+                        `Add a site with \`beryl envs update <env-id>\`, then create tests with ` +
+                        `\`beryl jobs create <document>\`.`,
                 };
             }
             const auth = flagStr(input, "auth") ?? (await resolveAuthChoice(ctx, ws, url));
@@ -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` +
-                        `Ready for your own tests: author a plan and push it with \`beryl tests create\`.`,
-                };
-            // 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>\`.`,
+            };
         },
     },
     {
@@ -227,6 +194,62 @@ export const projectCommands = [
             return { data: await ctx.client.patch(projectPath(workspaceId, projectId), body) };
         },
     },
+    {
+        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, 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 | android | ios, one or more",
+                required: true,
+                variadic: true,
+            },
+        ],
+        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), {
+                enabled_surfaces: argList(input, "surfaces"),
+            }));
+            return { data, human: `Enabled surfaces: ${data.enabled_surfaces.join(", ")}` };
+        },
+    },
+    {
+        name: "projects findings-gate",
+        summary: "Turn the findings gate on each run on or off",
+        description: "With the gate on (new-since-green), every run also reports a findings gate: failed " +
+            "when the environment's Site Health has a finding first seen after the last green run " +
+            "or came back after it (every current finding if there is no green run yet), unknown " +
+            "when Site Health has not run there or is not recording findings (its issue tracker " +
+            "must be connected). The gate sits next to the test verdicts and never changes one, nor the " +
+            "exit code of `runs watch`; read it from `findings_gate` on `runs get`. Off by default.",
+        scope: "project",
+        args: [{ name: "mode", description: "off | new-since-green", required: true }],
+        examples: ["beryl projects findings-gate new-since-green", "beryl projects findings-gate off"],
+        async run(ctx, input) {
+            const { workspaceId, projectId } = await ctx.requireProject(input);
+            const mode = arg(input, "mode").toLowerCase().replace(/-/g, "_");
+            if (mode !== "off" && mode !== "new_since_green") {
+                throw new UsageError(`Expected "off" or "new-since-green", got "${arg(input, "mode")}"`);
+            }
+            const data = (await ctx.client.patch(projectPath(workspaceId, projectId), {
+                findings_gate: mode,
+            }));
+            return { data, human: `Findings gate: ${data.findings_gate.replace(/_/g, "-")}` };
+        },
+    },
     {
         name: "projects delete",
         summary: "Delete a project and all its tests and runs",
@@ -258,7 +281,7 @@ export const projectCommands = [
     },
     {
         name: "projects report",
-        summary: "Aggregate quality report across recent runs (pass rates, flaky tests, trend)",
+        summary: "Aggregate quality report across recent runs (pass rates, per-test history, trend)",
         scope: "project",
         flags: [
             { name: "runs", type: "number", description: "How many recent runs to aggregate" },