@beryl-so/cli 0.38.0 → 0.40.0

package/README.md

@@ -359,11 +359,14 @@ Send product feedback to the Beryl team.
 
 ### billing
 
-Review a workspace's plan usage, subscription, and invoices.
+Review a workspace's plan usage, subscription, and invoices; upgrade or switch plans.
 
 | Command | Summary | MCP tool |
 | --- | --- | --- |
-| `beryl billing usage` | Show plan usage: monthly cloud run minutes | none |
+| `beryl billing plans` | List the plans: price, cloud run minutes, storage, overage terms | none |
+| `beryl billing usage` | Show plan usage: cloud run minutes, storage held, and this month's overage | none |
+| `beryl billing checkout` | Get a Stripe Checkout link that moves a Free workspace onto Team or Business | none |
+| `beryl billing plan` | Switch a paid workspace between Team and Business in place (prorated) | none |
 | `beryl billing subscription` | Show the workspace's subscription | none |
 | `beryl billing invoices` | List recent invoices | none |
 | `beryl billing portal` | Get a Stripe billing-portal link for the workspace | none |

package/dist/commands/account.js

@@ -43,16 +43,53 @@ export const accountCommands = [
             return { data: await ctx.client.post("/feedback", { message: arg(input, "message") }) };
         },
     },
+    {
+        name: "billing plans",
+        summary: "List the plans: price, cloud run minutes, storage, overage terms",
+        groupSummary: "Review a workspace's plan usage, subscription, and invoices; upgrade or switch plans.",
+        async run(ctx) {
+            return { data: await ctx.client.get("/billing/plans") };
+        },
+    },
     {
         name: "billing usage",
-        summary: "Show plan usage: monthly cloud run minutes",
+        summary: "Show plan usage: cloud run minutes, storage held, and this month's overage",
         scope: "workspace",
-        groupSummary: "Review a workspace's plan usage, subscription, and invoices.",
         async run(ctx, input) {
             const ws = await ctx.requireWorkspace(input);
             return { data: await ctx.client.get(`/workspaces/${ws}/billing/usage`) };
         },
     },
+    {
+        name: "billing checkout",
+        summary: "Get a Stripe Checkout link that moves a Free workspace onto Team or Business",
+        scope: "workspace",
+        flags: [
+            { name: "plan", type: "string", description: "team or business", required: true },
+        ],
+        async run(ctx, input) {
+            const ws = await ctx.requireWorkspace(input);
+            const plan = flagStr(input, "plan");
+            if (plan !== "team" && plan !== "business")
+                throw new UsageError("--plan must be team or business");
+            return { data: await ctx.client.post(`/workspaces/${ws}/billing/checkout`, { plan }) };
+        },
+    },
+    {
+        name: "billing plan",
+        summary: "Switch a paid workspace between Team and Business in place (prorated)",
+        scope: "workspace",
+        flags: [
+            { name: "plan", type: "string", description: "team or business", required: true },
+        ],
+        async run(ctx, input) {
+            const ws = await ctx.requireWorkspace(input);
+            const plan = flagStr(input, "plan");
+            if (plan !== "team" && plan !== "business")
+                throw new UsageError("--plan must be team or business");
+            return { data: await ctx.client.post(`/workspaces/${ws}/billing/plan`, { plan }) };
+        },
+    },
     {
         name: "billing subscription",
         summary: "Show the workspace's subscription",
@@ -82,11 +119,7 @@ export const accountCommands = [
         scope: "workspace",
         async run(ctx, input) {
             const ws = await ctx.requireWorkspace(input);
-            return {
-                data: await ctx.client.post(`/workspaces/${ws}/billing/portal`, {
-                    return_url: "https://beryl.so/settings/billing",
-                }),
-            };
+            return { data: await ctx.client.post(`/workspaces/${ws}/billing/portal`, {}) };
         },
     },
 ];

package/dist/commands/runs.js

@@ -74,6 +74,12 @@ export const runCommands = [
             },
             { name: "watch", type: "boolean", description: "Follow progress and exit non-zero on failure" },
             { name: "timeout", type: "number", description: "With --watch: max minutes to wait" },
+            {
+                name: "fail-fast",
+                type: "boolean",
+                description: "With --watch: cancel the run and exit 1 on the first failing test, instead of " +
+                    "waiting for the rest of the suite. Built for CI gates; off by default",
+            },
             {
                 name: "retries",
                 type: "number",
@@ -118,7 +124,10 @@ export const runCommands = [
             }));
             if (!flagBool(input, "watch"))
                 return { data: created };
-            return await watchRun(ctx, workspaceId, projectId, created.id, flagNum(input, "timeout"));
+            return await watchRun(ctx, workspaceId, projectId, created.id, flagNum(input, "timeout"), {
+                failFast: flagBool(input, "fail-fast"),
+                ci: process.env.GITHUB_ACTIONS === "true",
+            });
         },
     },
     {
@@ -575,10 +584,21 @@ export const runCommands = [
         description: "Replays what already happened, then follows live. Exits 0 only if every test passed.",
         scope: "project",
         args: [{ name: "run-id", description: "Run id", required: true }],
-        flags: [{ name: "timeout", type: "number", description: "Max minutes to wait" }],
+        flags: [
+            { name: "timeout", type: "number", description: "Max minutes to wait" },
+            {
+                name: "fail-fast",
+                type: "boolean",
+                description: "Cancel the run and exit 1 on the first failing test, instead of waiting for " +
+                    "the rest of the suite. Built for CI gates; off by default",
+            },
+        ],
         async run(ctx, input) {
             const { workspaceId, projectId } = await ctx.requireProject(input);
-            return await watchRun(ctx, workspaceId, projectId, arg(input, "run-id"), flagNum(input, "timeout"));
+            return await watchRun(ctx, workspaceId, projectId, arg(input, "run-id"), flagNum(input, "timeout"), {
+                failFast: flagBool(input, "fail-fast"),
+                ci: process.env.GITHUB_ACTIONS === "true",
+            });
         },
     },
     {

package/dist/commands/watch.js

@@ -1,3 +1,4 @@
+import fs from "node:fs";
 import { CliError } from "../errors.js";
 import { sseStream } from "../sse.js";
 import { dim, green, red, statusColor, yellow } from "../output.js";
@@ -10,8 +11,29 @@ function withTimeout(minutes) {
 const PROGRESS_WAIT_S = 25;
 const HEARTBEAT_MS = 180_000;
 const SETTLED = new Set(["passed", "failed", "errored", "cancelled"]);
+const FAILING = new Set(["failed", "errored"]);
 const TERMINAL_RUN = new Set(["completed", "failed", "cancelled"]);
 const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const CI_ERROR_MAX_LEN = 4_000;
+function runPageUrl(apiUrl, projectId, runId) {
+    if (!apiUrl)
+        return null;
+    let host;
+    try {
+        host = new URL(apiUrl).hostname;
+    }
+    catch {
+        return null;
+    }
+    const webapp = host === "api.beryl.so"
+        ? "https://beryl.so"
+        : host === "dev.beryl.so"
+            ? "https://preview.beryl.so"
+            : null;
+    return webapp ? `${webapp}/projects/${projectId}/runs/${runId}` : null;
+}
+const escapeAnnotationData = (s) => s.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A");
+const escapeAnnotationProp = (s) => escapeAnnotationData(s).replace(/:/g, "%3A").replace(/,/g, "%2C");
 function sleep(ms) {
     return new Promise((r) => setTimeout(r, ms));
 }
@@ -25,16 +47,18 @@ function settledCount(c) {
 // Watching a cloud run is a poll, not a stream: each request parks server-side
 // for up to PROGRESS_WAIT_S and returns when a test settles, so a dropped
 // request or an api deploy costs one retry instead of the whole watch.
-export async function watchRun(ctx, ws, project, runId, timeoutMinutes) {
+export async function watchRun(ctx, ws, project, runId, timeoutMinutes, opts = {}) {
     const path = projectPath(ws, project);
     const deadline = timeoutMinutes ? Date.now() + timeoutMinutes * 60_000 : undefined;
     const tty = Boolean(process.stderr.isTTY) && !ctx.json;
+    const ci = Boolean(opts.ci) && !ctx.json;
     const printed = new Set();
     let since = 0;
     let backoffMs = 2_000;
     let lastHeartbeat = Date.now();
     let spin = 0;
     let run = null;
+    let knownTotal = null;
     const clearStatusLine = () => {
         if (tty)
             process.stderr.write("\r\u001b[2K");
@@ -47,13 +71,21 @@ export async function watchRun(ctx, ws, project, runId, timeoutMinutes) {
         const mark = ok ? green("✓") : muted ? yellow("⚠") : red("✗");
         const label = muted ? yellow(`${r.status} (quarantined)`) : statusColor(r.status);
         const duration = r.duration_ms ? dim(` ${Math.round(r.duration_ms / 1000)}s`) : "";
-        const errorText = r.error_message ? ` ${String(r.error_message).slice(0, 120)}` : "";
+        const seq = ci ? dim(`${printed.size}/${knownTotal ?? "?"} `) : "";
+        const fullError = ci && !ok && !muted;
+        const errorText = r.error_message && !fullError ? ` ${String(r.error_message).slice(0, 120)}` : "";
         const error = errorText ? (muted ? dim(errorText) : red(errorText)) : "";
-        ctx.err(`${mark} ${label} ${dim(r.title || r.id)}${duration}${error}`);
+        ctx.err(`${seq}${mark} ${label} ${dim(r.title || r.id)}${duration}${error}`);
+        if (fullError && r.error_message) {
+            const detail = String(r.error_message).slice(0, CI_ERROR_MAX_LEN);
+            ctx.err(red(detail.replace(/^/gm, "    ")));
+            process.stdout.write(`::error title=${escapeAnnotationProp(r.title || r.id)}::${escapeAnnotationData(detail)}\n`);
+        }
     };
     if (!ctx.json)
         ctx.err(dim(`watching run ${runId}`));
     let lastCounters = {};
+    let failFastStop = false;
     while (true) {
         if (deadline && Date.now() > deadline) {
             clearStatusLine();
@@ -72,7 +104,12 @@ export async function watchRun(ctx, ws, project, runId, timeoutMinutes) {
             backoffMs = Math.min(backoffMs * 2, 30_000);
             continue;
         }
-        lastCounters = progress.counters ?? {};
+        // Not every event carries counters, so an empty snapshot means "no news",
+        // not "zero settled": keep the last populated one.
+        if (progress.counters && Object.keys(progress.counters).length > 0)
+            lastCounters = progress.counters;
+        if (lastCounters.total)
+            knownTotal = lastCounters.total;
         const version = Number(progress.version ?? 0);
         const changed = version !== since || TERMINAL_RUN.has(progress.status);
         since = version;
@@ -88,6 +125,8 @@ export async function watchRun(ctx, ws, project, runId, timeoutMinutes) {
                 backoffMs = Math.min(backoffMs * 2, 30_000);
                 continue;
             }
+            if (run?.total_tests)
+                knownTotal = run.total_tests;
             for (const r of run?.test_results ?? []) {
                 if (SETTLED.has(r.status) && !printed.has(r.id)) {
                     printed.add(r.id);
@@ -96,13 +135,30 @@ export async function watchRun(ctx, ws, project, runId, timeoutMinutes) {
                         ctx.out(JSON.stringify({ event: "test_completed", ...r }));
                     else
                         printRow(r);
+                    if (opts.failFast && FAILING.has(r.status) && !r.quarantined) {
+                        failFastStop = true;
+                        break;
+                    }
+                }
+            }
+            if (failFastStop) {
+                clearStatusLine();
+                if (!ctx.json)
+                    ctx.err(red(`fail-fast: cancelling run ${runId}`));
+                try {
+                    await ctx.client.post(`${path}/runs/${runId}/cancel`);
+                }
+                catch {
+                    // Best-effort: the cancel may race the worker or the run may already be
+                    // terminal; the failure that triggered it decides the exit code anyway.
                 }
+                break;
             }
             if (run && TERMINAL_RUN.has(run.status))
                 break;
         }
-        const done = settledCount(lastCounters);
-        const total = lastCounters.total ?? "?";
+        const done = Math.max(settledCount(lastCounters), printed.size);
+        const total = lastCounters.total || knownTotal || "?";
         if (tty) {
             spin = (spin + 1) % SPINNER.length;
             const reds = (lastCounters.failed ?? 0) + (lastCounters.errored ?? 0);
@@ -125,7 +181,7 @@ export async function watchRun(ctx, ws, project, runId, timeoutMinutes) {
         flaky: run?.summary?.flaky ?? 0,
         healed: run?.summary?.healed ?? 0,
     };
-    const finalStatus = run?.status ?? "unknown";
+    const finalStatus = failFastStop ? "failed" : (run?.status ?? "unknown");
     // Quarantined reds are excluded from `failed` by the API (they land in their own
     // counter), so they never reach this sum and never flip the exit code, but they
     // are always reported, so a green build never silently hides a muted failure.
@@ -142,8 +198,44 @@ export async function watchRun(ctx, ws, project, runId, timeoutMinutes) {
         : green(`${passed} passed`) + extra;
     if (!ctx.json)
         ctx.err(`\n${statusColor(finalStatus)}: ${summary}`);
+    const link = runPageUrl(ctx.client.baseUrl, project, runId);
+    if (ci && link)
+        ctx.err(dim(link));
+    if (ci && process.env.GITHUB_STEP_SUMMARY) {
+        const failures = (run?.test_results ?? []).filter((r) => FAILING.has(r.status) && !r.quarantined);
+        const md = [
+            `### Beryl run ${finalStatus}${failFastStop ? " (fail-fast)" : ""}`,
+            "",
+            "| passed | failed | errored | cancelled | quarantined | total |",
+            "| --- | --- | --- | --- | --- | --- |",
+            `| ${counters.passed} | ${counters.failed} | ${counters.errored} | ${counters.cancelled} | ${counters.quarantined} | ${counters.total} |`,
+            ...(link ? ["", `[Open the run in Beryl](${link})`] : []),
+            ...failures.flatMap((r) => [
+                "",
+                `**✗ ${r.title || r.id}**`,
+                "```",
+                String(r.error_message ?? "").slice(0, CI_ERROR_MAX_LEN),
+                "```",
+            ]),
+            "",
+        ];
+        try {
+            fs.appendFileSync(process.env.GITHUB_STEP_SUMMARY, md.join("\n"));
+        }
+        catch {
+            // The summary is decoration; never fail the watch over it.
+        }
+    }
     const exitCode = finalStatus === "completed" && failed === 0 ? 0 : 1;
-    return { data: { run_id: runId, status: finalStatus, ...counters }, exitCode };
+    return {
+        data: {
+            run_id: runId,
+            status: finalStatus,
+            ...(failFastStop ? { fail_fast: true } : {}),
+            ...counters,
+        },
+        exitCode,
+    };
 }
 export async function watchExploration(ctx, ws, project, explorationId, timeoutMinutes) {
     const signal = withTimeout(timeoutMinutes);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@beryl-so/cli",
-  "version": "0.38.0",
+  "version": "0.40.0",
   "description": "Beryl on the command line — projects, runs, the exploring agent, and an MCP server over the same commands.",
   "license": "MIT",
   "type": "module",