@beryl-so/cli 0.2.0 → 0.6.0

package/dist/local-run.js

@@ -0,0 +1,168 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+// The customer already has @playwright/test (the MCP `init` wires it), so we invoke it
+// as an external rather than bundling it — the CLI's zero-runtime-dep rule. In a node_modules
+// install `playwright` is on PATH; otherwise fall back to `npx playwright`, exactly as the
+// cloud runner does.
+export const PLAYWRIGHT_INSTALL_HINT = "Local Playwright not found. Install it in this project, then re-run:\n" +
+    "  npm i -D @playwright/test && npx playwright install chromium";
+// Isolate the run from any playwright.config.ts in the customer's repo: a stray `testMatch`
+// would exclude our spec (a zero-test run that reads as a false pass), and a `use.baseURL` /
+// `use.storageState` / `globalSetup` there would silently retarget or reauth the run we mean
+// to be a clean local execution of exactly this one spec. `testDir` pins us to our own dir.
+// Reporter is left to the CLI flag + PLAYWRIGHT_JSON_OUTPUT_NAME (as the cloud runner does), so
+// the report lands at exactly our path regardless of what a reporter here would default to.
+const ISOLATING_CONFIG = (testDir, artifactsDir) => `import { defineConfig } from "@playwright/test";\n` +
+    `export default defineConfig({\n` +
+    `  testDir: ${JSON.stringify(testDir)},\n` +
+    `  testMatch: "beryl-local.spec.ts",\n` +
+    `  outputDir: ${JSON.stringify(artifactsDir)},\n` +
+    `  fullyParallel: false,\n` +
+    `});\n`;
+const PASSING = new Set(["passed", "expected"]);
+const SKIPPED = new Set(["skipped"]);
+export class PlaywrightMissingError extends Error {
+}
+function runProcess(command, args, cwd, env) {
+    return new Promise((resolve) => {
+        const child = spawn(command, args, { cwd, env });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (d) => (stdout += d.toString()));
+        child.stderr.on("data", (d) => (stderr += d.toString()));
+        child.on("error", (err) => resolve({ code: null, stdout, stderr, spawnError: err }));
+        child.on("close", (code) => resolve({ code, stdout, stderr }));
+    });
+}
+// `npx playwright` is the portable fallback when no local binary is on PATH — it resolves
+// the project's @playwright/test without us hard-coding a node_modules path.
+function playwrightBase(cwd) {
+    const binName = process.platform === "win32" ? "playwright.cmd" : "playwright";
+    const local = path.join(cwd, "node_modules", ".bin", binName);
+    if (fs.existsSync(local))
+        return { command: local, args: ["test"] };
+    const npx = process.platform === "win32" ? "npx.cmd" : "npx";
+    return { command: npx, args: ["playwright", "test"] };
+}
+// "unknown command 'test'" is the Python `playwright` shim (no `test` subcommand); the module
+// errors mean @playwright/test isn't installed. Either way the actionable answer is the same
+// install hint, not a stack trace.
+function looksLikePlaywrightMissing(r) {
+    if (r.spawnError?.code === "ENOENT")
+        return true;
+    const blob = `${r.stdout}\n${r.stderr}`;
+    return (/unknown command ['"]?test/i.test(blob) ||
+        /Cannot find module ['"]@playwright\/test/i.test(blob) ||
+        /npm ERR!.*could not determine executable|npx.*not found/i.test(blob));
+}
+export function parsePlaywrightReport(data) {
+    const results = [];
+    const walk = (suites) => {
+        for (const suite of suites) {
+            for (const spec of suite.specs ?? []) {
+                for (const test of spec.tests ?? []) {
+                    // Last attempt is the verdict — retries can precede it.
+                    const last = test.results?.[test.results.length - 1];
+                    const errors = (last?.errors ?? []).map((e) => e.message).filter(Boolean);
+                    const artifacts = (last?.attachments ?? [])
+                        .map((a) => a.path)
+                        .filter((p) => Boolean(p));
+                    results.push({
+                        name: spec.title ?? "(unnamed)",
+                        status: last?.status ?? "unknown",
+                        duration_ms: last?.duration,
+                        ...(errors.length ? { error: errors.join("\n") } : {}),
+                        artifacts,
+                    });
+                }
+            }
+            if (suite.suites)
+                walk(suite.suites);
+        }
+    };
+    walk(data.suites ?? []);
+    return results;
+}
+// passed/failed exclude skips; an empty set is neither — the caller treats it as a failure
+// because a run that executed nothing is not evidence of a pass.
+export function tally(results) {
+    const passed = results.filter((r) => PASSING.has(r.status)).length;
+    const skipped = results.filter((r) => SKIPPED.has(r.status)).length;
+    return { passed, failed: results.length - passed - skipped };
+}
+function parseReport(reportPath) {
+    return parsePlaywrightReport(JSON.parse(fs.readFileSync(reportPath, "utf8")));
+}
+/**
+ * Write `spec` next to the caller's project, run it with their local @playwright/test, and
+ * parse the JSON report into a structured pass/fail summary. Artifacts + the spec + report land
+ * in `dir` when given (kept), otherwise in a temp dir that is cleaned up. Throws
+ * {@link PlaywrightMissingError} when no runnable @playwright/test is found so the caller can
+ * print an install hint.
+ */
+export async function runSpecLocally(opts) {
+    const cwd = process.cwd();
+    // The spec + isolating config MUST sit inside the project tree: Playwright resolves
+    // `@playwright/test` (imported by both) by walking UP from the config file, so a config in
+    // /tmp finds no node_modules and every run dies with "Cannot find module '@playwright/test'".
+    // A run dir under cwd walks up into the project's node_modules; it's always cleaned up.
+    const runDir = fs.mkdtempSync(path.join(cwd, ".beryl-local-"));
+    // Where the user-facing outputs (artifacts, spec copy, report) go: --dir if asked, else the
+    // ephemeral run dir.
+    const outDir = opts.dir ? path.resolve(opts.dir) : runDir;
+    fs.mkdirSync(outDir, { recursive: true });
+    const specPath = path.join(runDir, "beryl-local.spec.ts");
+    fs.writeFileSync(specPath, opts.spec);
+    const configPath = path.join(runDir, "beryl-local.config.ts");
+    const artifactsDir = path.join(outDir, "artifacts");
+    fs.writeFileSync(configPath, ISOLATING_CONFIG(runDir, artifactsDir));
+    const reportPath = path.join(runDir, "report.json");
+    const cleanup = () => fs.rmSync(runDir, { recursive: true, force: true });
+    const { command, args: base } = playwrightBase(cwd);
+    const args = [...base, `--config=${configPath}`, "--reporter=json"];
+    opts.onProgress?.(`Running ${command} ${base.join(" ")} on ${opts.testName}…`);
+    const env = { ...process.env, PLAYWRIGHT_JSON_OUTPUT_NAME: reportPath };
+    const result = await runProcess(command, args, cwd, env);
+    if (looksLikePlaywrightMissing(result)) {
+        cleanup();
+        throw new PlaywrightMissingError(PLAYWRIGHT_INSTALL_HINT);
+    }
+    let results;
+    try {
+        results = parseReport(reportPath);
+    }
+    catch (err) {
+        // No parsable report on a non-zero exit means the spec never ran (compile/launch error) —
+        // surface stderr/stdout so it isn't a silent failure.
+        const detail = (result.stderr || result.stdout || err.message).trim();
+        cleanup();
+        throw new Error(`Playwright produced no readable report — the spec did not run.\n${detail}`);
+    }
+    // A run that executed zero tests is a failure, not a pass — an isolating config matching
+    // exactly our spec should never yield an empty set, so an empty one means the spec was
+    // filtered/skipped away and there is no evidence it ran.
+    if (results.length === 0) {
+        const detail = (result.stderr || result.stdout || "no tests were run").trim();
+        cleanup();
+        throw new Error(`Playwright ran no tests from the rendered spec.\n${detail}`);
+    }
+    let keptSpec = specPath;
+    let keptReport = reportPath;
+    if (opts.dir) {
+        // Persist the exact spec + report next to the artifacts before the run dir is removed.
+        keptSpec = path.join(outDir, "beryl-local.spec.ts");
+        keptReport = path.join(outDir, "report.json");
+        fs.copyFileSync(specPath, keptSpec);
+        fs.copyFileSync(reportPath, keptReport);
+    }
+    else {
+        // Without --dir the artifacts lived in the run dir we're about to delete, so their paths
+        // would dangle — don't hand back paths to files that no longer exist.
+        for (const r of results)
+            r.artifacts = [];
+    }
+    cleanup();
+    const { passed, failed } = tally(results);
+    return { passed, failed, results, directory: outDir, spec: keptSpec, report: keptReport };
+}

package/dist/registry/index.js

@@ -4,10 +4,12 @@ import { configCommands } from "../commands/config-vars.js";
 import { credentialCommands } from "../commands/credentials.js";
 import { environmentCommands } from "../commands/environments.js";
 import { explorationCommands } from "../commands/explorations.js";
+import { inboxCommands } from "../commands/inboxes.js";
 import { initCommands } from "../commands/init.js";
 import { mcpCommands } from "../commands/mcp.js";
 import { projectCommands } from "../commands/projects.js";
 import { runCommands } from "../commands/runs.js";
+import { slackCommands } from "../commands/slack.js";
 import { testCommands } from "../commands/tests.js";
 import { workspaceCommands } from "../commands/workspaces.js";
 export const WORKSPACE_FLAG = {
@@ -43,7 +45,9 @@ export const commands = [
     ...runCommands,
     ...explorationCommands,
     ...configCommands,
+    ...slackCommands,
     ...credentialCommands,
+    ...inboxCommands,
     ...accountCommands,
     ...mcpCommands,
 ].map(withScopeFlags);
@@ -73,6 +77,9 @@ export function findCommand(words) {
 export function groupDefault(group) {
     return commands.find((spec) => spec.groupDefault && spec.name.split(" ")[0] === group);
 }
+export function groupSummary(specs) {
+    return specs.find((s) => s.groupSummary)?.groupSummary;
+}
 export function commandGroups() {
     const groups = new Map();
     for (const spec of commands) {

package/dist/schema.generated.js

@@ -15,11 +15,24 @@ export const ACTION_PLAN_SCHEMA = {
                 "wait_for",
                 "expect",
                 "capture_count",
-                "await_email"
+                "await_email",
+                "upload",
+                "dialog",
+                "switch_tab",
+                "close_tab",
+                "drag"
             ],
             "title": "ActionType",
             "type": "string"
         },
+        "DialogChoice": {
+            "enum": [
+                "accept",
+                "dismiss"
+            ],
+            "title": "DialogChoice",
+            "type": "string"
+        },
         "EmailExtract": {
             "enum": [
                 "code",
@@ -356,6 +369,109 @@ export const ACTION_PLAN_SCHEMA = {
                         ]
                     }
                 },
+                {
+                    "if": {
+                        "properties": {
+                            "action": {
+                                "const": "upload"
+                            }
+                        },
+                        "required": [
+                            "action"
+                        ]
+                    },
+                    "then": {
+                        "properties": {
+                            "selector": {
+                                "minLength": 1,
+                                "type": "string"
+                            },
+                            "value": {
+                                "minLength": 1,
+                                "type": "string"
+                            }
+                        },
+                        "required": [
+                            "selector",
+                            "value"
+                        ]
+                    }
+                },
+                {
+                    "if": {
+                        "properties": {
+                            "action": {
+                                "const": "dialog"
+                            }
+                        },
+                        "required": [
+                            "action"
+                        ]
+                    },
+                    "then": {
+                        "properties": {
+                            "dialog": {
+                                "not": {
+                                    "type": "null"
+                                }
+                            }
+                        },
+                        "required": [
+                            "dialog"
+                        ]
+                    }
+                },
+                {
+                    "if": {
+                        "properties": {
+                            "action": {
+                                "const": "switch_tab"
+                            }
+                        },
+                        "required": [
+                            "action"
+                        ]
+                    },
+                    "then": {
+                        "properties": {
+                            "value": {
+                                "minLength": 1,
+                                "type": "string"
+                            }
+                        },
+                        "required": [
+                            "value"
+                        ]
+                    }
+                },
+                {
+                    "if": {
+                        "properties": {
+                            "action": {
+                                "const": "drag"
+                            }
+                        },
+                        "required": [
+                            "action"
+                        ]
+                    },
+                    "then": {
+                        "properties": {
+                            "selector": {
+                                "minLength": 1,
+                                "type": "string"
+                            },
+                            "value": {
+                                "minLength": 1,
+                                "type": "string"
+                            }
+                        },
+                        "required": [
+                            "selector",
+                            "value"
+                        ]
+                    }
+                },
                 {
                     "if": {
                         "properties": {
@@ -774,6 +890,29 @@ export const ACTION_PLAN_SCHEMA = {
                     "default": null,
                     "title": "Capture Ref"
                 },
+                "dialog": {
+                    "anyOf": [
+                        {
+                            "$ref": "#/$defs/DialogChoice"
+                        },
+                        {
+                            "type": "null"
+                        }
+                    ],
+                    "default": null
+                },
+                "dialog_expect_text": {
+                    "anyOf": [
+                        {
+                            "type": "string"
+                        },
+                        {
+                            "type": "null"
+                        }
+                    ],
+                    "default": null,
+                    "title": "Dialog Expect Text"
+                },
                 "expect_count": {
                     "anyOf": [
                         {
@@ -860,6 +999,18 @@ export const ACTION_PLAN_SCHEMA = {
                     "default": null,
                     "title": "From Contains"
                 },
+                "iframe": {
+                    "anyOf": [
+                        {
+                            "type": "string"
+                        },
+                        {
+                            "type": "null"
+                        }
+                    ],
+                    "default": null,
+                    "title": "Iframe"
+                },
                 "key": {
                     "anyOf": [
                         {

package/package.json

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