@bugmole/cli 0.4.0 → 0.6.0

package/src/billing/plan-catalog.test.ts

@@ -2,7 +2,20 @@ import assert from "node:assert/strict";
 import { readFile } from "node:fs/promises";
 import test from "node:test";
 import { COPY_HEADER, catalogCopy, catalogSource } from "../../scripts/sync-plan-catalog.mjs";
-import { AI_CREDIT_COST, PLANS, entitlementsFor, formatUsd, includedQuantity, overageCents } from "./plan-catalog.js";
+import {
+  AI_CREDIT_COST,
+  PLANS,
+  PLAN_IDS,
+  PRICING_ROWS,
+  PRICING_UNLISTED,
+  catalogPricingKeys,
+  entitlementsFor,
+  formatUsd,
+  includedQuantity,
+  overageCents,
+  pricingCell,
+  pricingValue,
+} from "./plan-catalog.js";
 
 test("the dashboard's copy of the plan catalog matches the source", async () => {
   const [source, copy] = await Promise.all([readFile(catalogSource, "utf8"), readFile(catalogCopy, "utf8")]);
@@ -26,8 +39,11 @@ test("free usage stops at the allowance while paid plans can buy more", () => {
   assert.equal(overageCents(free, "device_minute"), null);
   const team = entitlementsFor("team");
   assert.equal(overageCents(team, "browser_minute"), 4);
-  assert.equal(overageCents(team, "device_minute"), 25);
+  assert.equal(overageCents(team, "device_minute"), null, "Team has no device clouds, so no real-device minutes");
   assert.equal(includedQuantity(team, "device_minute"), 0);
+  assert.equal(overageCents(entitlementsFor("business"), "device_minute"), 25);
+  assert.equal(overageCents(entitlementsFor("business"), "browser_minute"), 3);
+  assert.equal(overageCents(entitlementsFor("team", { features: { deviceClouds: true } }), "device_minute"), 25, "a contract that adds device clouds adds device minutes");
   assert.equal(includedQuantity(team, "ai_credit"), 1500);
 });
 
@@ -44,3 +60,67 @@ test("AI credit costs match the pricing page", () => {
   assert.equal(formatUsd(24_900), "$249");
   assert.equal(formatUsd(4), "$0.04");
 });
+
+test("real-device minutes are priced only where device clouds are included", () => {
+  for (const plan of Object.values(PLANS)) {
+    const priced = overageCents(entitlementsFor(plan.id), "device_minute") !== null;
+    assert.equal(priced, plan.features.deviceClouds, plan.id);
+  }
+});
+
+test("only Enterprise lists contract extras, and they are descriptive only", () => {
+  for (const id of ["free", "team", "business"] as const) {
+    assert.ok(Object.values(PLANS[id].extras).every((value) => value === false), id);
+  }
+  assert.ok(Object.values(PLANS.enterprise.extras).every((value) => value === true));
+  assert.equal("extras" in entitlementsFor("enterprise"), false, "entitlements never carry contract extras");
+});
+
+test("every plan includes the everyone-gets features", () => {
+  for (const plan of Object.values(PLANS)) {
+    for (const key of ["unlimitedUsers", "unlimitedLocalRuns", "desktopBrowsers", "emulatedMobile", "aiFailureAnalysis"] as const) {
+      assert.equal(plan.features[key], true, `${plan.id}.${key}`);
+    }
+  }
+});
+
+test("every pricing row names a real catalog key", () => {
+  for (const row of PRICING_ROWS) {
+    for (const plan of PLAN_IDS) assert.notEqual(pricingValue(plan, row.key), undefined, `${row.key} on ${plan}`);
+  }
+  assert.equal(pricingValue("team", "features.notAThing"), undefined);
+  assert.equal(pricingValue("team", "limits.seats"), undefined);
+  assert.equal(new Set(PRICING_ROWS.map((row) => row.key)).size, PRICING_ROWS.length, "no duplicate rows");
+});
+
+test("every catalog feature, extra and limit is on the pricing page or deliberately unlisted", () => {
+  const shown = new Set<string>(PRICING_ROWS.map((row) => row.key));
+  for (const key of catalogPricingKeys()) {
+    assert.ok(shown.has(key) || PRICING_UNLISTED[key], `${key} is in the catalog but not on the pricing page`);
+    assert.ok(!(shown.has(key) && PRICING_UNLISTED[key]), `${key} is both shown and unlisted`);
+  }
+  for (const key of Object.keys(PRICING_UNLISTED)) assert.ok((catalogPricingKeys() as string[]).includes(key), `unlisted ${key} is not a catalog key`);
+});
+
+test("pricing cells follow the catalog", () => {
+  const row = (key: string) => PRICING_ROWS.find((item) => item.key === key)!;
+  assert.equal(pricingCell("team", row("features.teams")), "\u2713");
+  assert.equal(pricingCell("free", row("features.teams")), "\u2014");
+  assert.equal(pricingCell("team", row("overage.browser_minute")), "$0.04 / min");
+  assert.equal(pricingCell("business", row("overage.browser_minute")), "$0.03 / min");
+  assert.equal(pricingCell("team", row("overage.device_minute")), "\u2014");
+  assert.equal(pricingCell("business", row("overage.device_minute")), "$0.25 / min");
+  assert.equal(pricingCell("enterprise", row("overage.browser_minute")), "Volume pricing", "contract usage isn't shown at list rates");
+  assert.equal(pricingCell("team", row("limits.cloudMinutes")), "3,000");
+  assert.equal(pricingCell("enterprise", row("limits.projects")), "Custom");
+  assert.equal(pricingCell("business", row("limits.historyDays")), "90 days");
+  assert.equal(pricingCell("free", row("limits.inactiveProjectDays")), "30 days");
+  assert.equal(pricingCell("team", row("limits.inactiveProjectDays")), "Never", "no limit reads Never, not Custom");
+  assert.equal(pricingCell("enterprise", row("limits.inactiveProjectDays")), "Never");
+});
+
+test("only Free pauses inactive projects, and contracts can change it", () => {
+  assert.equal(entitlementsFor("free").inactiveProjectDays, 30);
+  for (const id of ["team", "business", "enterprise"] as const) assert.equal(entitlementsFor(id).inactiveProjectDays, null, id);
+  assert.equal(entitlementsFor("enterprise", { inactiveProjectDays: 90 }).inactiveProjectDays, 90);
+});

package/src/billing/plan-catalog.ts

@@ -12,6 +12,16 @@ export type UsageKind = "browser_minute" | "device_minute" | "ai_credit";
 export type AiAction = "analysis" | "repair" | "exploration" | "discovery";
 
 export type PlanFeatures = {
+  /** Every plan: no per-seat pricing. */
+  unlimitedUsers: boolean;
+  /** Every plan: runs on your own machines and CI are never counted. */
+  unlimitedLocalRuns: boolean;
+  /** Every plan: Chrome, Firefox, Safari and Edge. */
+  desktopBrowsers: boolean;
+  /** Every plan: emulated iPhone and Android viewports. */
+  emulatedMobile: boolean;
+  /** Every plan: AI explains a failed run (uses AI credits). */
+  aiFailureAnalysis: boolean;
   prChecks: boolean;
   slack: boolean;
   teams: boolean;
@@ -38,12 +48,55 @@ export type PlanDef = {
   aiCredits: number | null;
   parallel: number | null;
   historyDays: number | null;
+  /**
+   * Days without any activity (a run, a task, exploration, a CLI/MCP call or a
+   * dashboard change) before a project is paused; null means never. A paused
+   * project is read-only and doesn't count toward `projects` until someone
+   * activates it again.
+   */
+  inactiveProjectDays: number | null;
+  /**
+   * How far one exploration on Bugmole Cloud goes: pages opened, and clicks
+   * from home. A project's own machine sets its own (BUGMOLE_DISCOVERY_MAX_*).
+   */
+  discovery: { maxPages: number; maxDepth: number };
   /** Cents per unit beyond the allowance; null means usage stops at the allowance. */
   overage: { browserMinuteCents: number | null; creditCents: number | null };
   features: PlanFeatures;
+  /**
+   * What a contract adds beyond the limits and features above, as shown on the
+   * pricing page. Descriptive only: NOT enforced by the registry or read by
+   * feature flags; the contract itself sets them up.
+   */
+  extras: PlanExtras;
 };
 
-const NO_FEATURES: PlanFeatures = {
+/** Descriptive, contract-only plan extras (never enforced; see PlanDef.extras). */
+export type PlanExtras = {
+  dedicatedInfrastructure: boolean;
+  privateDevices: boolean;
+  ownModelAndStorage: boolean;
+  customRetention: boolean;
+  sla: boolean;
+  volumePricing: boolean;
+};
+
+const NO_EXTRAS: PlanExtras = {
+  dedicatedInfrastructure: false,
+  privateDevices: false,
+  ownModelAndStorage: false,
+  customRetention: false,
+  sla: false,
+  volumePricing: false,
+};
+
+/** What every plan, Free included, gets; paid plans add to it. */
+const BASE_FEATURES: PlanFeatures = {
+  unlimitedUsers: true,
+  unlimitedLocalRuns: true,
+  desktopBrowsers: true,
+  emulatedMobile: true,
+  aiFailureAnalysis: true,
   prChecks: false,
   slack: false,
   teams: false,
@@ -68,8 +121,11 @@ export const PLANS: Record<PlanId, PlanDef> = {
     aiCredits: 100,
     parallel: 2,
     historyDays: 7,
+    inactiveProjectDays: 30,
+    discovery: { maxPages: 12, maxDepth: 2 },
     overage: { browserMinuteCents: null, creditCents: null },
-    features: { ...NO_FEATURES },
+    features: { ...BASE_FEATURES },
+    extras: { ...NO_EXTRAS },
   },
   team: {
     id: "team",
@@ -82,8 +138,11 @@ export const PLANS: Record<PlanId, PlanDef> = {
     aiCredits: 1_500,
     parallel: 8,
     historyDays: 30,
+    inactiveProjectDays: null,
+    discovery: { maxPages: 40, maxDepth: 3 },
     overage: { browserMinuteCents: 4, creditCents: 1 },
-    features: { ...NO_FEATURES, prChecks: true, slack: true, teams: true, aiFixes: true },
+    features: { ...BASE_FEATURES, prChecks: true, slack: true, teams: true, aiFixes: true },
+    extras: { ...NO_EXTRAS },
   },
   business: {
     id: "business",
@@ -96,9 +155,11 @@ export const PLANS: Record<PlanId, PlanDef> = {
     aiCredits: 7_500,
     parallel: 25,
     historyDays: 90,
+    inactiveProjectDays: null,
+    discovery: { maxPages: 100, maxDepth: 4 },
     overage: { browserMinuteCents: 3, creditCents: 1 },
     features: {
-      ...NO_FEATURES,
+      ...BASE_FEATURES,
       prChecks: true,
       slack: true,
       teams: true,
@@ -108,6 +169,7 @@ export const PLANS: Record<PlanId, PlanDef> = {
       auditLogExport: true,
       prioritySupport: true,
     },
+    extras: { ...NO_EXTRAS },
   },
   enterprise: {
     id: "enterprise",
@@ -120,8 +182,11 @@ export const PLANS: Record<PlanId, PlanDef> = {
     aiCredits: null,
     parallel: null,
     historyDays: 365,
+    inactiveProjectDays: null,
+    discovery: { maxPages: 250, maxDepth: 5 },
     overage: { browserMinuteCents: 3, creditCents: 1 },
     features: {
+      ...BASE_FEATURES,
       prChecks: true,
       slack: true,
       teams: true,
@@ -133,6 +198,16 @@ export const PLANS: Record<PlanId, PlanDef> = {
       prioritySupport: true,
       selfHostedWorkers: true,
     },
+    // Agreed per contract; additional usage is priced there too, not at the list
+    // rates above (which only apply until a contract sets its own).
+    extras: {
+      dedicatedInfrastructure: true,
+      privateDevices: true,
+      ownModelAndStorage: true,
+      customRetention: true,
+      sla: true,
+      volumePricing: true,
+    },
   },
 };
 
@@ -150,12 +225,12 @@ export const AI_CREDIT_COST: Record<AiAction, number> = {
 export const DEVICE_FARM_CENTS_PER_MIN = 25;
 
 /** Contract-specific adjustments stored with a workspace's plan (Enterprise, trials). */
-export type PlanOverrides = Partial<Pick<PlanDef, "projects" | "cloudMinutes" | "aiCredits" | "parallel" | "historyDays">> & {
+export type PlanOverrides = Partial<Pick<PlanDef, LimitKey>> & {
   features?: Partial<PlanFeatures>;
   overage?: Partial<PlanDef["overage"]>;
 };
 
-export type Entitlements = Omit<PlanDef, "name" | "audience" | "priceMonthlyCents" | "priceYearlyMonthlyCents">;
+export type Entitlements = Omit<PlanDef, "name" | "audience" | "priceMonthlyCents" | "priceYearlyMonthlyCents" | "extras">;
 
 export function isPlanId(value: unknown): value is PlanId {
   return typeof value === "string" && (PLAN_IDS as string[]).includes(value);
@@ -163,7 +238,7 @@ export function isPlanId(value: unknown): value is PlanId {
 
 export function entitlementsFor(plan: PlanId, overrides: PlanOverrides = {}): Entitlements {
   const base = PLANS[plan];
-  const pick = <K extends "projects" | "cloudMinutes" | "aiCredits" | "parallel" | "historyDays">(key: K) =>
+  const pick = <K extends LimitKey>(key: K) =>
     overrides[key] !== undefined ? (overrides[key] as PlanDef[K]) : base[key];
   return {
     id: base.id,
@@ -172,6 +247,8 @@ export function entitlementsFor(plan: PlanId, overrides: PlanOverrides = {}): En
     aiCredits: pick("aiCredits"),
     parallel: pick("parallel"),
     historyDays: pick("historyDays"),
+    inactiveProjectDays: pick("inactiveProjectDays"),
+    discovery: { ...base.discovery },
     overage: { ...base.overage, ...overrides.overage },
     features: { ...base.features, ...overrides.features },
   };
@@ -188,8 +265,8 @@ export function includedQuantity(entitlements: Entitlements, kind: UsageKind): n
 export function overageCents(entitlements: Entitlements, kind: UsageKind): number | null {
   if (kind === "browser_minute") return entitlements.overage.browserMinuteCents;
   if (kind === "ai_credit") return entitlements.overage.creditCents;
-  // Real devices need a paid plan with a subscription; the registry checks that.
-  return entitlements.id === "free" ? null : DEVICE_FARM_CENTS_PER_MIN;
+  // Real devices come with device clouds (Business and up), billed as you go.
+  return entitlements.features.deviceClouds ? DEVICE_FARM_CENTS_PER_MIN : null;
 }
 
 export function formatUsd(cents: number, { minimumFractionDigits }: { minimumFractionDigits?: number } = {}): string {
@@ -197,3 +274,129 @@ export function formatUsd(cents: number, { minimumFractionDigits }: { minimumFra
   const fraction = minimumFractionDigits ?? (Number.isInteger(dollars) ? 0 : 2);
   return `$${dollars.toLocaleString("en-US", { minimumFractionDigits: fraction, maximumFractionDigits: Math.max(fraction, 2) })}`;
 }
+
+// ---------- pricing page ----------
+// The bugmole.com pricing page renders every plan feature, extra and limit from
+// these rows, so a row can't claim something the catalog doesn't grant. A test
+// fails when a catalog key has no row here and isn't in PRICING_UNLISTED.
+
+export type LimitKey = "projects" | "cloudMinutes" | "aiCredits" | "parallel" | "historyDays" | "inactiveProjectDays";
+export type PricingKey =
+  | `features.${keyof PlanFeatures}`
+  | `extras.${keyof PlanExtras}`
+  | `limits.${LimitKey}`
+  | `overage.${UsageKind}`;
+
+export type PricingRow = {
+  key: PricingKey;
+  /** Compare-table row label. */
+  label: string;
+  /** Plan-card bullet, when it differs from the label; for an overage, {value} is the rate. */
+  card?: string;
+  /** Unit after a limit or overage value: " days", " / min", " each". */
+  unit?: string;
+  /** What a limit of null (no limit) reads as; "Custom" when unset. */
+  unlimited?: string;
+};
+
+export const LIMIT_KEYS: LimitKey[] = ["projects", "cloudMinutes", "aiCredits", "parallel", "historyDays", "inactiveProjectDays"];
+
+export const PRICING_ROWS: PricingRow[] = [
+  { key: "features.unlimitedUsers", label: "Unlimited users" },
+  { key: "features.unlimitedLocalRuns", label: "Unlimited local & CI runs" },
+  { key: "features.desktopBrowsers", label: "Chrome, Firefox, Safari & Edge" },
+  { key: "features.emulatedMobile", label: "Emulated iPhone & Android" },
+  { key: "features.aiFailureAnalysis", label: "AI failure analysis" },
+  { key: "limits.projects", label: "Projects" },
+  { key: "limits.cloudMinutes", label: "Cloud minutes / month" },
+  { key: "limits.aiCredits", label: "AI credits / month" },
+  { key: "limits.parallel", label: "Cloud runs at once" },
+  { key: "limits.historyDays", label: "Run history", unit: " days" },
+  { key: "limits.inactiveProjectDays", label: "Projects paused after inactivity", unit: " days", unlimited: "Never" },
+  { key: "overage.browser_minute", label: "Additional cloud minutes", unit: " / min" },
+  { key: "overage.ai_credit", label: "Additional AI credits", unit: " each" },
+  {
+    key: "overage.device_minute",
+    label: "Real-device minutes (Bugmole device cloud)",
+    card: "Real devices on Bugmole's device cloud at {value}, pay as you go",
+    unit: " / min",
+  },
+  { key: "features.prChecks", label: "PR checks" },
+  { key: "features.slack", label: "Slack alerts" },
+  { key: "features.teams", label: "Microsoft Teams alerts" },
+  { key: "features.aiFixes", label: "AI test fixes" },
+  {
+    key: "features.deviceClouds",
+    label: "Device clouds (simulators, emulators, real devices)",
+    card: "iOS simulators, Android emulators & real devices through BrowserStack, Kobiton or AWS Device Farm",
+  },
+  { key: "features.sso", label: "SSO" },
+  { key: "features.auditLogExport", label: "Audit log export" },
+  { key: "features.prioritySupport", label: "Priority support" },
+  { key: "features.scim", label: "SCIM provisioning" },
+  { key: "features.selfHostedWorkers", label: "Self-hosted workers" },
+  { key: "extras.dedicatedInfrastructure", label: "Dedicated infrastructure" },
+  { key: "extras.privateDevices", label: "Private devices" },
+  { key: "extras.ownModelAndStorage", label: "Your own AI model and storage" },
+  { key: "extras.customRetention", label: "Custom retention" },
+  { key: "extras.sla", label: "SLA" },
+  { key: "extras.volumePricing", label: "Volume pricing" },
+];
+
+/**
+ * Catalog keys deliberately left off the pricing page, each with the reason.
+ * Empty today: everything a plan grants is shown.
+ */
+export const PRICING_UNLISTED: Partial<Record<PricingKey, string>> = {};
+
+/** Every key the catalog defines for a plan, in pricing-key form. */
+export function catalogPricingKeys(): PricingKey[] {
+  const plan = PLANS.free;
+  return [
+    ...(Object.keys(plan.features) as Array<keyof PlanFeatures>).map((key) => `features.${key}` as const),
+    ...(Object.keys(plan.extras) as Array<keyof PlanExtras>).map((key) => `extras.${key}` as const),
+    ...LIMIT_KEYS.map((key) => `limits.${key}` as const),
+    ...(["browser_minute", "ai_credit", "device_minute"] as UsageKind[]).map((key) => `overage.${key}` as const),
+  ];
+}
+
+/**
+ * A plan's raw value for a pricing key: a flag, a limit (null: set per
+ * contract) or cents per unit (null: not available). undefined means the key
+ * isn't in the catalog.
+ */
+export function pricingValue(plan: PlanId, key: string): boolean | number | null | undefined {
+  const [group, name] = key.split(".");
+  if (!name || !isPlanId(plan)) return undefined;
+  const def = PLANS[plan];
+  if (group === "features") return Object.hasOwn(def.features, name) ? def.features[name as keyof PlanFeatures] : undefined;
+  if (group === "extras") return Object.hasOwn(def.extras, name) ? def.extras[name as keyof PlanExtras] : undefined;
+  if (group === "limits") return (LIMIT_KEYS as string[]).includes(name) ? entitlementsFor(plan)[name as LimitKey] : undefined;
+  if (group === "overage") {
+    return (["browser_minute", "ai_credit", "device_minute"] as string[]).includes(name)
+      ? overageCents(entitlementsFor(plan), name as UsageKind)
+      : undefined;
+  }
+  return undefined;
+}
+
+/** Whether a plan has a row's feature, extra or overage at all (limits always apply). */
+export function pricingIncluded(plan: PlanId, row: PricingRow): boolean {
+  const value = pricingValue(plan, row.key);
+  if (value === undefined) throw new Error(`Unknown pricing key: ${row.key}`);
+  return value !== false && value !== null;
+}
+
+/** The compare-table cell for a plan: ✓ or — for flags, the value with its unit otherwise. */
+export function pricingCell(plan: PlanId, row: PricingRow): string {
+  const value = pricingValue(plan, row.key);
+  if (value === undefined) throw new Error(`Unknown pricing key: ${row.key}`);
+  if (typeof value === "boolean") return value ? "\u2713" : "\u2014";
+  const custom = PLANS[plan].priceMonthlyCents === null;
+  if (row.key.startsWith("overage.")) {
+    // Contract plans price additional usage in the contract, not at list rates.
+    if (custom) return value === null ? "\u2014" : "Volume pricing";
+    return value === null ? "\u2014" : `${formatUsd(value, { minimumFractionDigits: 2 })}${row.unit ?? ""}`;
+  }
+  return value === null ? (row.unlimited ?? "Custom") : `${value.toLocaleString("en-US")}${row.unit ?? ""}`;
+}