@beryl-so/cli 0.52.0 → 0.54.0

package/README.md

@@ -13,9 +13,10 @@ npx @beryl-so/cli@latest init
 ```
 
 Signs you in (browser approval by default, emailed one-time code as fallback; new
-emails are signed up on the spot), wires the beryl + playwright MCP servers into Claude
-Code or Cursor, installs the beryl-test authoring skill, and installs Playwright for
-local runs. Safe to re-run.
+emails are signed up on the spot), wires the beryl + playwright MCP servers into the
+agent you pick with --claude, --cursor, --vscode or --opencode (it asks when you pass
+none), installs the beryl-test authoring skill, and installs Playwright for local runs.
+Safe to re-run.
 
 ## Install
 

package/dist/adapters/mcp.js

@@ -9,7 +9,7 @@ import { AuthError, CliError } from "../errors.js";
 import { ApiClient, ApiError } from "../http.js";
 import { parseArgv } from "./cli.js";
 import { commands } from "../registry/index.js";
-import { analyticsOptions, createPostHogClient, setClient, setSurface, shutdownTelemetry, withTool, } from "../telemetry.js";
+import { analyticsOptions, createPostHogClient, captureMcpSessionStarted, setClient, setSurface, shutdownTelemetry, withTool, } from "../telemetry.js";
 import { refreshInstalledSkills } from "../commands/init.js";
 import { cliVersion, warnIfStale } from "../version-check.js";
 export function toolName(spec) {
@@ -353,7 +353,11 @@ export async function serveMcp(baseCtx) {
             };
         }
     });
-    server.oninitialized = () => setClient(server.getClientVersion());
+    // Emitted here, not at boot: the handshake is what carries the client's name.
+    server.oninitialized = () => {
+        setClient(server.getClientVersion());
+        void captureMcpSessionStarted(baseCtx.config.apiUrl, identifyUser(baseCtx));
+    };
     instrument(server, createPostHogClient(), analyticsOptions(baseCtx.config.apiUrl, identifyUser(baseCtx)));
     // A coding agent ends an MCP server either by closing the pipe or by signalling it, and
     // only the first path reaches onclose — without these the last batch of events dies with

package/dist/commands/auth.js

@@ -73,7 +73,7 @@ async function otpLogin(ctx, input, codeFlag) {
             const why = `${email} signs in with Google, so there is no emailed code`;
             if (!ctx.interactive) {
                 throw new UsageError(`${why} — run \`beryl login\` in a terminal to sign in via the browser, ` +
-                    "or pass --token with a token from beryl.so → Account → API tokens");
+                    "or pass --token with a token from beryl.so → Account → Personal access tokens");
             }
             ctx.err(`${why} — confirm the sign-in in your browser instead.`);
             const fromBrowser = await deviceLogin(ctx, process.stdin, flagStr(input, "token-name"));
@@ -99,8 +99,8 @@ export const authCommands = [
         description: "Signs in via your browser (a code you confirm at beryl.so) and stores a personal " +
             "access token in the CLI config. Pass --otp (or --email) to skip the browser and " +
             "sign in with an emailed one-time code instead. A new email gets an account " +
-            "created automatically. Pass --token to use an existing token from Account → API " +
-            "tokens. Pass --email plus --code (the 6 digits from the email, e.g. read from a " +
+            "created automatically. Pass --token to use an existing token from Account → " +
+            "Personal access tokens. Pass --email plus --code (the 6 digits from the email, e.g. read from a " +
             "`beryl inbox`) to complete the OTP flow without a prompt. In CI, prefer the " +
             "BERYL_API_KEY environment variable.",
         interactive: true,

package/dist/commands/init.js

@@ -4,7 +4,7 @@ import os from "node:os";
 import path from "node:path";
 import { BERYL_COPILOT_MARK_BEGIN, BERYL_COPILOT_MARK_END, BERYL_COPILOT_SECTION, BERYL_CURSOR_RULE, BERYL_CURSOR_RULE_FILENAME, BERYL_TEST_SKILL, BERYL_TEST_SKILL_DIR, BERYL_TEST_SKILL_FILENAME, } from "../beryl-test-skill.js";
 import { loadConfig } from "../config.js";
-import { AuthError, CliError } from "../errors.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";
@@ -31,9 +31,27 @@ const PLAYWRIGHT_SERVER_ENTRY = {
 // with `type`, unlike Cursor/Claude's `mcpServers`. Same pinned commands, different shape.
 const VSCODE_MCP_SERVER_ENTRY = { type: "stdio", ...MCP_SERVER_ENTRY };
 const VSCODE_PLAYWRIGHT_SERVER_ENTRY = { type: "stdio", ...PLAYWRIGHT_SERVER_ENTRY };
-const ACTION_PLAN_SCHEMA_URL = "https://api.beryl.so/api/v1/schemas/action-plan.schema.json";
+// opencode flattens command + args into one array under `mcp`.
+function opencodeEntry(entry) {
+    return { type: "local", command: [entry.command, ...entry.args], enabled: true };
+}
+const MANUAL_SETUP_DOCS = "https://beryl.so/docs/mcp#manual";
+// Printed for the agents init cannot wire, from the same entries the flags write.
+// Hand-formatted rather than JSON.stringify so args stay on one line.
+function snippetEntry(name, entry) {
+    const args = entry.args.map((a) => JSON.stringify(a)).join(", ");
+    return `        "${name}": { "command": ${JSON.stringify(entry.command)}, "args": [${args}] }`;
+}
+const MANUAL_CONFIG_SNIPPET = [
+    "    {",
+    '      "mcpServers": {',
+    `${snippetEntry("beryl", MCP_SERVER_ENTRY)},`,
+    snippetEntry("playwright", PLAYWRIGHT_SERVER_ENTRY),
+    "      }",
+    "    }",
+].join("\n");
 // `key` is the container the editor expects: `mcpServers` for Claude/Cursor, `servers` for
-// VS Code. `entries` are the editor-shaped server objects (VS Code tags them with `type`).
+// VS Code, `mcp` for opencode. `entries` are the editor-shaped server objects.
 function mergeMcpConfig(file, key, entries) {
     let existing = {};
     if (fs.existsSync(file)) {
@@ -105,6 +123,33 @@ function vscodeUserConfigDir() {
     const dir = vscodeUserConfigDirFor(process.platform, os.homedir(), process.env);
     return fs.existsSync(dir) ? dir : null;
 }
+// The Claude DESKTOP app, which is a different surface from Claude Code and a different
+// file from ~/.claude.json: macOS ~/Library/Application Support/Claude, Windows
+// %APPDATA%/Claude, Linux ~/.config/Claude. Pure resolver so all three are testable.
+export function claudeDesktopConfigDirFor(platform, home, env) {
+    return platform === "darwin"
+        ? path.join(home, "Library", "Application Support", "Claude")
+        : platform === "win32"
+            ? path.join(env.APPDATA ?? path.join(home, "AppData", "Roaming"), "Claude")
+            : path.join(env.XDG_CONFIG_HOME ?? path.join(home, ".config"), "Claude");
+}
+// JSONC may carry comments JSON.parse rejects, so never rewrite it.
+export function opencodeConfigFileFor(dir) {
+    const jsonc = path.join(dir, "opencode.jsonc");
+    if (fs.existsSync(jsonc) && !fs.existsSync(path.join(dir, "opencode.json"))) {
+        return { file: jsonc, jsonc: true };
+    }
+    return { file: path.join(dir, "opencode.json"), jsonc: false };
+}
+function opencodeConfigFile(scope, cwd) {
+    return opencodeConfigFileFor(scope === "user" ? path.join(os.homedir(), ".config", "opencode") : cwd);
+}
+// Null when the app isn't installed. Checked BEFORE writing because mergeMcpConfig
+// mkdirs its parent, which would leave a stray config dir on machines without the app.
+export function claudeDesktopConfigFile() {
+    const dir = claudeDesktopConfigDirFor(process.platform, os.homedir(), process.env);
+    return fs.existsSync(dir) ? path.join(dir, "claude_desktop_config.json") : null;
+}
 // Write generated content that ships with the CLI and changes every release, so anything
 // that differs is overwritten: a stale copy silently feeds agents months-old guidance,
 // which is worse than losing a local edit the user can redo (and `beryl guide` still prints
@@ -217,59 +262,88 @@ async function ensureLocalPlaywright(ctx, cwd) {
             `    ${cyan(installCommandsFor(gaps, cwd))}`);
     }
 }
+const CLIENTS = [
+    ["claude", "Claude Code + Claude desktop app"],
+    ["cursor", "Cursor"],
+    ["vscode", "VS Code / Copilot"],
+    ["opencode", "opencode"],
+];
+// Whole commands, not bare flags: this is printed for someone who has to go run it.
+const CLIENT_COMMAND_HINT = CLIENTS.map(([k, label]) => `    npx @beryl-so/cli@latest init --${k.padEnd(9)}  ${label}`).join("\n");
+// Picker labels are precise ("Claude Code + Claude desktop app"); prose wants short.
+const CLIENT_SHORT_NAMES = CLIENTS.map(([, label]) => label.split(" + ")[0].split(" / ")[0]);
+const CLIENT_LABEL_LIST = `${CLIENT_SHORT_NAMES.slice(0, -1).join(", ")} or ${CLIENT_SHORT_NAMES.at(-1)}`;
+// Flags win; no flag and no TTY selects nothing.
+async function selectClients(ctx, flags) {
+    const flagged = CLIENTS.map(([k]) => k).filter((k) => flags[k]);
+    if (flagged.length > 0)
+        return new Set(flagged);
+    if (!ctx.interactive)
+        return new Set();
+    ctx.err("Which agent should Beryl wire?");
+    CLIENTS.forEach(([, label], i) => ctx.err(`  ${i + 1}. ${label}`));
+    ctx.err(`  ${CLIENTS.length + 1}. Other`);
+    const answer = await ctx.prompt("Selection (comma-separated) [1]: ");
+    const picks = (answer.trim() || "1")
+        .split(",")
+        .map((part) => Number.parseInt(part.trim(), 10));
+    if (picks.some((n) => !Number.isInteger(n) || n < 1 || n > CLIENTS.length + 1)) {
+        throw new UsageError(`Pick 1-${CLIENTS.length + 1}, or pass a client flag:\n${CLIENT_COMMAND_HINT}`);
+    }
+    return new Set(picks.filter((n) => n <= CLIENTS.length).map((n) => CLIENTS[n - 1][0]));
+}
 export const initCommands = [
     {
         name: "init",
         summary: "Set up Beryl in this repo: sign in and wire up your coding agent",
-        description: "One-command onboarding: signs you in (browser confirm, or an emailed one-time code) " +
-            "and wires up your coding " +
-            "agent. Nothing is detected and nothing is conditional: every run wires the beryl AND " +
-            "playwright MCP servers, writes the authoring skill (user scope: your home " +
-            ".agents/skills/ + .claude/skills/, so it follows you into every session; --scope " +
-            "project: the repo's own dirs, committed for teammates), and installs the Chromium " +
-            "browser if missing (the Playwright runner ships with the CLI, so any repo can run tests " +
-            "locally), since browser authoring and local runs depend on it. By default the " +
-            "servers are wired per-user (matching where your login token lives) via `claude mcp add " +
-            "-s user`; pass --scope project to write a committed .mcp.json for a shared repo " +
-            "instead. With --cursor the same two servers are also wired into Cursor and a repo-local " +
-            ".cursor/rules/beryl.mdc authoring rule is written (Cursor's equivalent of the skill, " +
-            "since it reads neither skills dir); --vscode does the same for VS Code / GitHub Copilot " +
-            "(VS Code's user mcp.json, or .vscode/mcp.json with --scope project, plus a marked " +
-            "section in .github/copilot-instructions.md). No " +
-            "workspace/project pin and no URL prompt: ask Claude to write tests for " +
-            "your site and it resolves the workspace, project, and URL. Safe to re-run: every run " +
-            "refreshes the authoring skill to this CLI's version (overwriting an older or edited " +
-            "copy; `beryl guide` prints the same content), and skips whatever else is already set " +
-            "up.",
+        description: "Signs you in, wires the beryl and playwright MCP servers into the coding agent you " +
+            "pick, writes the beryl-test authoring skill, and installs Chromium if it is missing. " +
+            "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 " +
+            "and reopen to pick the config up. --scope user (default) configures everything " +
+            "per-user, matching where your login token lives; --scope project writes config " +
+            "committed to the repo. Safe to re-run: it refreshes the skill to this CLI's version " +
+            "and skips whatever is already set up.",
         interactive: true,
         flags: [
             {
                 name: "scope",
                 type: "string",
                 enum: ["user", "project"],
-                description: "Where to wire the MCP servers. `user` (default) configures them per-user (matching " +
-                    "where your Beryl login token lives) via `claude mcp add -s user`. `project` writes a " +
-                    "committed .mcp.json for a shared repo. Every teammate still runs `beryl login` to " +
-                    "authenticate",
+                description: "Where to wire: `user` (default) is per-user, `project` is committed to the repo. " +
+                    "Every teammate still runs `beryl login` to authenticate",
+            },
+            {
+                name: "claude",
+                type: "boolean",
+                description: "Wire Claude Code (`claude mcp add -s user`, or a committed .mcp.json under " +
+                    "--scope project), plus the Claude desktop app when it is installed",
             },
             {
                 name: "cursor",
                 type: "boolean",
-                description: "Also wire the same two MCP servers into Cursor's config and write a repo-local " +
-                    ".cursor/rules/beryl.mdc authoring rule (Cursor's equivalent of the skill)",
+                description: "Wire Cursor, plus a repo-local .cursor/rules/beryl.mdc authoring rule, since " +
+                    "Cursor reads no skills dir",
             },
             {
                 name: "vscode",
                 type: "boolean",
-                description: "Also wire the two MCP servers into VS Code's user config (or .vscode/mcp.json with " +
-                    "--scope project) and add a Beryl section to .github/copilot-instructions.md for Copilot",
+                description: "Wire VS Code's user mcp.json (or .vscode/mcp.json under --scope project), plus a " +
+                    "Beryl section in .github/copilot-instructions.md for Copilot",
+            },
+            {
+                name: "opencode",
+                type: "boolean",
+                description: "Wire ~/.config/opencode/opencode.json (or the repo's opencode.json under " +
+                    "--scope project), in opencode's own config shape",
             },
         ],
         examples: [
             "npx @beryl-so/cli@latest init",
-            "beryl init --scope project",
-            "beryl init --cursor",
-            "beryl init --vscode",
+            "beryl init --claude",
+            "beryl init --cursor --opencode",
+            "beryl init --vscode --scope project",
         ],
         async run(ctx, input) {
             const cwd = process.cwd();
@@ -311,12 +385,19 @@ export const initCommands = [
             else {
                 await signIn();
             }
+            // A signed-in init with no account id is a bug, not a reason to skip: the alias is
+            // the only thing joining pre-login CLI events to the person who later signs up.
             if (accountId) {
                 aliasMachineToAccount(accountId);
-                flushTelemetry();
             }
+            else if (config.token) {
+                captureCliEvent("cli_alias_skipped", config.apiUrl, { reason: "no_account_id" });
+            }
+            flushTelemetry();
             const report = (label, fresh, where) => ctx.err(`${green("✓")} ${label} ${fresh ? "configured" : "already configured"} ${dim(where)}`);
-            if (scope === "user") {
+            // No "nothing wired" notice here: the closing message below says it once, in full.
+            const clients = await selectClients(ctx, input.flags);
+            if (clients.has("claude") && scope === "user") {
                 // Claude Code owns ~/.claude.json — shell out to `claude mcp add` rather than write it.
                 const berylOk = claudeUserAdd("beryl", MCP_SERVER_ENTRY);
                 const playwrightOk = claudeUserAdd("playwright", PLAYWRIGHT_SERVER_ENTRY);
@@ -329,7 +410,7 @@ export const initCommands = [
                     ctx.err(`    ${cyan(claudeAddHint("playwright", PLAYWRIGHT_SERVER_ENTRY))}`);
                 }
             }
-            else {
+            else if (clients.has("claude")) {
                 const file = path.join(cwd, ".mcp.json");
                 const wrote = mergeMcpConfig(file, "mcpServers", {
                     beryl: MCP_SERVER_ENTRY,
@@ -339,7 +420,20 @@ export const initCommands = [
                 report("beryl MCP", wrote.beryl, where);
                 report("playwright MCP", wrote.playwright, where);
             }
-            if (input.flags.cursor) {
+            // 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,
+                });
+                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) {
+                    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,
@@ -357,7 +451,7 @@ export const initCommands = [
             // VS Code (Copilot) is always repo-local: `.vscode/mcp.json` for the servers and a
             // marked section in `.github/copilot-instructions.md` for the guide pointer. VS Code's
             // per-user MCP config is managed through its UI, not a portable file, so scope is moot.
-            if (input.flags.vscode) {
+            if (clients.has("vscode")) {
                 // User scope (default) targets VS Code's real profile mcp.json, so it works in
                 // every project. Project scope, or a missing profile dir, falls back to the repo.
                 const userDir = scope === "user" ? vscodeUserConfigDir() : null;
@@ -383,6 +477,26 @@ export const initCommands = [
                         "Copilot may not read it. Run --vscode from your project root."));
                 }
             }
+            // opencode reads ~/.claude/skills/, so writeSkills covers it.
+            if (clients.has("opencode")) {
+                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({
+                        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 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);
             for (const skill of skills) {
                 const rel = path.relative(cwd, skill.file);
@@ -398,17 +512,27 @@ export const initCommands = [
                 ctx.err(`${green("✓")} Beryl authoring skill ${what} ${dim(where)}`);
             }
             await ensureLocalPlaywright(ctx, cwd);
-            // Name the editor's own agent, so the message speaks to what the user just set up.
-            const ed = input.flags.vscode
-                ? { open: "open VS Code", agent: "Copilot" }
-                : input.flags.cursor
+            // 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" }
+                : clients.has("cursor")
                     ? { open: "open Cursor", agent: "Cursor" }
-                    : { open: "open your editor", agent: "Claude" };
-            const nextSteps = `\n${bold(`Beryl is set up. Now ${ed.open} and ask ${ed.agent} to write tests.`)}\n` +
-                `  ${dim(`• Say: "write tests for https://your-app.com" and ${ed.agent} picks your workspace/project`)}\n` +
-                `  ${dim("  and sets the URL for you (no pin, no prompt).")}\n` +
-                `  ${dim(`• Playwright MCP is wired, so ${ed.agent} can drive a real browser to author from your plan.`)}\n` +
-                `\nAuthor against the ActionPlan JSON Schema: ${cyan(ACTION_PLAN_SCHEMA_URL)}`;
+                    : clients.has("vscode")
+                        ? { open: "open VS Code", agent: "Copilot" }
+                        : { open: "open opencode", agent: "opencode" };
+            const nextSteps = clients.size === 0
+                ? `\n${bold("Beryl is signed in and the authoring skill is installed.")}\n` +
+                    `  ${dim("• No MCP server is wired yet, so no agent can reach Beryl.")}\n` +
+                    `  ${dim(`• Using ${CLIENT_LABEL_LIST}? Re-run and pick it:`)}\n` +
+                    `    ${cyan("npx @beryl-so/cli@latest init")}\n` +
+                    `  ${dim("• Any other agent: add this to its MCP config, then restart it.")}\n` +
+                    `${cyan(MANUAL_CONFIG_SNIPPET)}\n` +
+                    `    ${dim("Some clients name that key `servers` or `mcp`.")}\n` +
+                    `    ${yellow(`Details: ${MANUAL_SETUP_DOCS}`)}\n`
+                : `\n${bold(`Beryl is set up. Now ${ed.open} and ask ${ed.agent} to write tests.`)}\n` +
+                    `  ${dim(`• Say: "write tests for https://example.com" and ${ed.agent} picks your workspace/project`)}\n` +
+                    `  ${dim("  and sets the URL for you (no pin, no prompt).")}\n` +
+                    `  ${dim(`• Playwright MCP is wired, so ${ed.agent} can drive a real browser to author from your plan.`)}\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)));

package/dist/telemetry.js

@@ -227,6 +227,9 @@ export function baseEventProperties(apiUrl) {
         // Same uuid as the X-Beryl-Session header, so a PostHog session and the Sentry tags
         // on the API requests it caused describe the same thing.
         beryl_session_id: sessionId,
+        // Also a property, not only the distinct id: an event whose alias never landed
+        // is still joinable to the install afterwards.
+        machine_id: machineId(),
     };
 }
 let posthog;
@@ -263,6 +266,40 @@ export function aliasMachineToAccount(userId) {
         // telemetry must never break a command
     }
 }
+/**
+ * One event per MCP server boot, so "connected but never called a tool" is measurable.
+ *
+ * Until this existed the surface was invisible until its first `test_created` /
+ * `run_created`, which hid the drop-off between wiring the MCP up and using it. Attributed
+ * to the account when a token resolves, else to the install, which a later alias merges.
+ * Best-effort: a failed identify still emits the event rather than losing the boot.
+ */
+export async function captureMcpSessionStarted(apiUrl, resolveIdentity) {
+    let identity = null;
+    try {
+        identity = await resolveIdentity();
+    }
+    catch {
+        // unauthenticated, or the lookup failed: fall back to the install
+    }
+    const client = currentClient();
+    try {
+        createPostHogClient().capture({
+            distinctId: identity?.distinctId ?? machineId(),
+            event: "mcp_session_started",
+            properties: {
+                ...baseEventProperties(apiUrl),
+                surface: "mcp",
+                authenticated: identity !== null,
+                client: client?.name,
+                client_version: client?.version,
+            },
+        });
+    }
+    catch {
+        // telemetry must never break a command
+    }
+}
 export function flushTelemetry() {
     // Fire-and-forget: init keeps running (login, installs) while the batch goes out, and a
     // failed send must never surface to the user.

package/package.json

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