@beryl-so/cli 0.34.4 → 0.36.0

package/README.md

@@ -30,6 +30,9 @@ From the monorepo (development): `cd cli && npm install && npm run build && npm
 latest npm release; a stale MCP server silently exposes fewer tools. Set
 `BERYL_NO_UPDATE_CHECK=1` to opt out.
 
+The CLI reports which commands run (never their arguments or output) so onboarding can
+be measured; set `BERYL_TELEMETRY=0` or `DO_NOT_TRACK=1` to send nothing.
+
 ## Authenticate
 
 ```bash
@@ -329,7 +332,7 @@ Durable identities on the site under test: what an authenticated test signs in a
 | --- | --- | --- |
 | `beryl accounts list` | List the test accounts an environment's tests sign in as | `accounts_list` |
 | `beryl accounts create` | Add a test account: the customer's own, or one Beryl signs up | `accounts_create` |
-| `beryl accounts provision <account-id>` | Prove a test account can get in, by replaying a plan that ends logged in | `accounts_provision` |
+| `beryl accounts signup <account-id>` | Store a test account's signup plan and sign it up on its environment | `accounts_signup` |
 | `beryl accounts set-login <account-id>` | Store the sign-in plan a run replays once, plus the probe that proves it | `accounts_set_login` |
 | `beryl accounts get-login <account-id>` | Read the stored sign-in plan, its probe, and the hash a safe write must cite | `accounts_get_login` |
 | `beryl accounts check <account-id>` | Sign in now and prove the session survives into a fresh browser | `accounts_check` |

package/dist/adapters/cli.js

@@ -4,7 +4,7 @@ import { CliError, EXIT_OK, EXIT_USAGE, UsageError } from "../errors.js";
 import { ApiClient } from "../http.js";
 import { autoFormat, bold, cyan, dim } from "../output.js";
 import { commandGroups, findCommand, groupSummary } from "../registry/index.js";
-import { withTool } from "../telemetry.js";
+import { captureCliEvent, shutdownTelemetry, withTool, } from "../telemetry.js";
 import { cliVersion } from "../version-check.js";
 import { mcpToolFor } from "./mcp.js";
 export const GLOBAL_FLAGS = [
@@ -324,6 +324,10 @@ export async function runCli(argv) {
         config.token = parsed.token;
     const client = new ApiClient(config.apiUrl, config.token);
     const ctx = createContext({ client, config, json: parsed.json, mcp: false });
+    // The MCP server reports its own tool calls; every other invocation is one command.
+    if (spec.name !== "mcp") {
+        captureCliEvent("cli_command", config.apiUrl, { command: spec.name });
+    }
     try {
         const result = (await withTool(spec.name, () => spec.run(ctx, parsed.input))) ?? {};
         if (parsed.json) {
@@ -345,4 +349,7 @@ export async function runCli(argv) {
         }
         throw err;
     }
+    finally {
+        await shutdownTelemetry();
+    }
 }

package/dist/adapters/mcp.js

@@ -250,14 +250,7 @@ export function identifyUser(baseCtx) {
                 if (me?.id) {
                     identity = {
                         distinctId: me.id,
-                        // Internal dogfooding is stamped rather than dropped: unlike the webapp we
-                        // want our own MCP sessions visible when debugging, so dashboards exclude
-                        // them by cohort instead.
-                        properties: {
-                            email: me.email,
-                            name: me.name,
-                            is_internal: Boolean(me.is_vibemonitor),
-                        },
+                        properties: { email: me.email, name: me.name },
                     };
                 }
             }

package/dist/beryl-test-skill.js

@@ -154,13 +154,14 @@ An empty \`accounts list\` means nothing is set up. In order of preference:
    \`beryl accounts create --email <email> --password <password>\`. A DEDICATED test
    account only — never a real user's.
 2. **No credentials, but the app has a signup form** → let Beryl make one.
-   \`beryl accounts create --type beryl\`, then prove it with
-   \`beryl accounts provision <id> --file <plan.json>\`. The plan is any ActionPlan that
-   ends LOGGED IN — a signup filling \`{{mailbox_address}}\` and \`{{login_password}}\`
-   for a new account, or a **sign-in** for one that already exists (hand-made, or the
-   record was lost); both prove the same thing. No password sign-in? Pass
-   \`--login-method otp\` (or \`magic_link\`) and let the plan \`await_email\` through —
-   later sign-ins read the same mailbox.
+   \`beryl accounts create --type beryl\`, then sign it up with
+   \`beryl accounts signup <id> --file <signup-plan.json>\`. The plan is the app's own
+   signup form as an ActionPlan, ending LOGGED IN, filling \`{{mailbox_address}}\` and
+   \`{{login_password}}\`. It stays on the account, so a new environment signs the same
+   identity up again by itself. An account that already exists on the site (hand-made,
+   or the record was lost) skips signup: store its sign-in with \`accounts set-login\`.
+   No password sign-in? Pass \`--login-method otp\` (or \`magic_link\`) and let the plan
+   \`await_email\` through; later sign-ins read the same mailbox.
 3. **Neither** → the flow is not testable authenticated. Say so rather than guessing.
 
 A project with no accounts falls back to the \`LOGIN_EMAIL\` variable +

package/dist/commands/accounts.js

@@ -63,7 +63,7 @@ export const testAccountCommands = [
         description: "Two kinds. `--type user_provided` records a dedicated account you already have on " +
             "the site: pass --email and --password, and it is usable immediately. `--type beryl` " +
             "reserves one Beryl will sign up itself, addressed at the project mailbox. It starts " +
-            "`pending` and becomes usable after `beryl accounts provision`. " +
+            "`pending` and becomes usable after `beryl accounts signup`. " +
             "The first account an environment gets is its default whatever you pass.",
         scope: "project",
         flags: [
@@ -111,8 +111,8 @@ export const testAccountCommands = [
                 is_default: flagBool(input, "default"),
             }));
             const next = account.status === "pending"
-                ? yellow(`\nNot proven yet — run:\n  beryl accounts provision ${account.id} --file <plan.json>\n` +
-                    `with a plan that ends logged in (a signup, or a sign-in if it already exists).`)
+                ? yellow(`\nNot signed up yet. Run:\n  beryl accounts signup ${account.id} --file <signup-plan.json>\n` +
+                    `with the app's signup form as a plan that ends logged in.`)
                 : "";
             return {
                 data: account,
@@ -121,15 +121,15 @@ export const testAccountCommands = [
         },
     },
     {
-        name: "accounts provision",
-        summary: "Prove a test account can get in, by replaying a plan that ends logged in",
-        description: "Runs the plan once in a real browser and, if it passes, marks the account ready. " +
-            "The plan is an ordinary ActionPlan that ends logged in: a SIGNUP when the account " +
-            "does not exist yet, or a SIGN-IN when it already does (you created it by hand, or " +
-            "the site already had it). Either proves the same thing, and a sign-in is what every " +
-            "later test will do anyway. Type {{mailbox_address}} into the email field and " +
-            "{{login_password}} into the password field. Both resolve at replay time, and an " +
-            "`await_email` step reads the project mailbox, so a verification code works.",
+        name: "accounts signup",
+        summary: "Store a test account's signup plan and sign it up on its environment",
+        description: "Runs the app's signup form once in a real browser and, if it ends logged in, marks " +
+            "the account ready. The plan is an ordinary ActionPlan of the SIGNUP flow. Type " +
+            "{{mailbox_address}} into the email field and {{login_password}} into the password " +
+            "field. Both resolve at replay time, and an `await_email` step reads the project " +
+            "mailbox, so a verification code works. The plan is kept on the account, so the " +
+            "same identity can be signed up again on a new environment. For an account that " +
+            "already exists on the site, store its sign-in with `accounts set-login` instead.",
         scope: "project",
         args: [{ name: "account-id", description: "Account id from `beryl accounts list`", required: true }],
         flags: [
@@ -137,20 +137,17 @@ export const testAccountCommands = [
                 name: "file",
                 type: "string",
                 required: true,
-                description: "ActionPlan that ends logged in, as JSON (path, or - for stdin)",
+                description: "The signup ActionPlan, ending logged in, as JSON (path, or - for stdin)",
             },
         ],
-        examples: [
-            "beryl accounts provision acc_123 --file signup-plan.json",
-            "beryl accounts provision acc_123 --file signin-plan.json",
-        ],
+        examples: ["beryl accounts signup acc_123 --file signup-plan.json"],
         async run(ctx, input) {
             const { workspaceId, projectId } = await ctx.requireProject(input);
-            const account = (await ctx.client.post(`${accountsPath(workspaceId, projectId)}/${arg(input, "account-id")}/provision`, { plan: readJsonFlag(input, "file") }));
+            const account = (await ctx.client.post(`${accountsPath(workspaceId, projectId)}/${arg(input, "account-id")}/signup`, { plan: readJsonFlag(input, "file") }));
             if (account.status !== "ready")
                 return {
                     data: account,
-                    human: `${yellow("The account could not get in")}: ${account.last_error ?? account.status}`,
+                    human: `${yellow("The signup did not get in")}: ${account.last_error ?? account.status}`,
                     exitCode: 1,
                 };
             return {

package/dist/commands/auth.js

@@ -5,6 +5,7 @@ import { deviceLogin, SWITCH_TO_OTP } from "../device-login.js";
 import { CliError, UsageError } from "../errors.js";
 import { ApiClient } from "../http.js";
 import { dim, green } from "../output.js";
+import { aliasMachineToAccount, flushTelemetry } from "../telemetry.js";
 import { arg, flagBool, flagStr } from "./util.js";
 function gitEmail() {
     try {
@@ -172,6 +173,8 @@ export const authCommands = [
                 token,
                 api_url: apiUrl === "https://api.beryl.so" ? undefined : apiUrl,
             });
+            aliasMachineToAccount(me.id);
+            flushTelemetry();
             const human = `${green("Logged in")} as ${me.name} <${me.email}>` +
                 `\n${dim(`Token saved to ${saved}`)}`;
             return {

package/dist/commands/init.js

@@ -8,7 +8,7 @@ import { AuthError, CliError } 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 { aliasSessionToAccount, captureCliEvent, flushTelemetry, shutdownTelemetry, } from "../telemetry.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";
@@ -227,7 +227,7 @@ export const initCommands = [
                 await signIn();
             }
             if (accountId) {
-                aliasSessionToAccount(accountId);
+                aliasMachineToAccount(accountId);
                 flushTelemetry();
             }
             const report = (label, fresh, where) => ctx.err(`${green("✓")} ${label} ${fresh ? "configured" : "already configured"} ${dim(where)}`);

package/dist/config.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -45,3 +46,13 @@ export function saveGlobalConfig(patch, env = process.env) {
     }
     return file;
 }
+// One id per install: every CLI event from this machine lands on it, and a login aliases
+// it onto the account, so an install joins the same PostHog person as the signup.
+export function machineId(env = process.env) {
+    const current = readJson(globalConfigPath(env)) ?? {};
+    if (current.machine_id)
+        return current.machine_id;
+    const id = randomUUID();
+    saveGlobalConfig({ machine_id: id }, env);
+    return id;
+}

package/dist/telemetry.js

@@ -1,6 +1,7 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { randomUUID } from "node:crypto";
 import { PostHog } from "posthog-node";
+import { machineId } from "./config.js";
 import { cliVersion } from "./version-check.js";
 // The webapp already ships this public (write-only) project key in its JS bundle, and
 // dev/prod deploys share it — environments are separated by the `environment` property
@@ -229,22 +230,38 @@ export function baseEventProperties(apiUrl) {
     };
 }
 let posthog;
+export function telemetryDisabled(env = process.env) {
+    return env.BERYL_TELEMETRY === "0" || env.DO_NOT_TRACK === "1";
+}
 export function createPostHogClient() {
-    posthog ??= new PostHog(POSTHOG_KEY, { host: POSTHOG_HOST, disableGeoip: false });
+    posthog ??= new PostHog(POSTHOG_KEY, {
+        host: POSTHOG_HOST,
+        disableGeoip: false,
+        disabled: telemetryDisabled(),
+    });
     return posthog;
 }
-// `beryl init` starts before there is an account to attribute to: its events land on the
-// process session id, and the session is aliased onto the account once init has signed in,
-// so the install joins the same person as the signup and the later MCP work.
+// CLI events land on the install's machine id, which a login aliases onto the account:
+// an install made before there is an account still joins the person who later signs up.
 export function captureCliEvent(event, apiUrl, properties = {}) {
-    createPostHogClient().capture({
-        distinctId: sessionId,
-        event,
-        properties: { ...baseEventProperties(apiUrl), ...properties },
-    });
+    try {
+        createPostHogClient().capture({
+            distinctId: machineId(),
+            event,
+            properties: { ...baseEventProperties(apiUrl), ...properties },
+        });
+    }
+    catch {
+        // telemetry must never break a command
+    }
 }
-export function aliasSessionToAccount(userId) {
-    createPostHogClient().alias({ distinctId: userId, alias: sessionId });
+export function aliasMachineToAccount(userId) {
+    try {
+        createPostHogClient().alias({ distinctId: userId, alias: machineId() });
+    }
+    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

package/package.json

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