@vibecheckai/cli 3.0.10 → 3.1.1

package/bin/runners/lib/__tests__/entitlements-v2.test.js

@@ -1,295 +1,295 @@
-/**
- * Entitlements v2 Tests - Tier Enforcement Verification
- * 
- * These tests verify:
- * 1. No bypass via env vars (VIBECHECK_SKIP_AUTH, VIBECHECK_OWNER, etc.)
- * 2. Correct tier gating for each command/feature
- * 3. Proper exit codes (3 = feature not allowed)
- * 4. Downgrade behaviors work correctly
- * 5. Help output shows correct tier labels
- */
-
-const {
-  getTier,
-  getLimits,
-  enforce,
-  checkCommand,
-  tierMeetsMinimum,
-  getMinTierForFeature,
-  tierHasFeature,
-  TIERS,
-  ENTITLEMENTS,
-  LIMITS,
-  EXIT_FEATURE_NOT_ALLOWED,
-  EXIT_MISCONFIG,
-} = require("../entitlements-v2");
-
-describe("Entitlements v2 - Tier Enforcement", () => {
-  // Store original env
-  const originalEnv = { ...process.env };
-  
-  beforeEach(() => {
-    // Reset env before each test
-    process.env = { ...originalEnv };
-    // Clear any env vars that might bypass
-    delete process.env.VIBECHECK_SKIP_AUTH;
-    delete process.env.VIBECHECK_OWNER;
-    delete process.env.VIBECHECK_DEMO;
-    delete process.env.OWNER_MODE;
-  });
-  
-  afterAll(() => {
-    process.env = originalEnv;
-  });
-
-  describe("No Bypass Tests", () => {
-    test("VIBECHECK_SKIP_AUTH does NOT grant paid features", async () => {
-      process.env.VIBECHECK_SKIP_AUTH = "1";
-      
-      // prove is PRO-only
-      const result = await enforce("prove", { silent: true });
-      expect(result.allowed).toBe(false);
-      expect(result.exitCode).toBe(EXIT_FEATURE_NOT_ALLOWED);
-    });
-
-    test("VIBECHECK_OWNER does NOT grant paid features", async () => {
-      process.env.VIBECHECK_OWNER = "1";
-      
-      const result = await enforce("prove", { silent: true });
-      expect(result.allowed).toBe(false);
-    });
-
-    test("VIBECHECK_DEMO does NOT grant paid features", async () => {
-      process.env.VIBECHECK_DEMO = "1";
-      
-      const result = await enforce("ai-test", { silent: true });
-      expect(result.allowed).toBe(false);
-    });
-
-    test("OWNER_MODE does NOT grant paid features", async () => {
-      process.env.OWNER_MODE = "true";
-      
-      const result = await enforce("share", { silent: true });
-      expect(result.allowed).toBe(false);
-    });
-
-    test("Offline mode defaults to FREE tier (no escalation)", async () => {
-      // Without API key, should be FREE
-      const tier = await getTier({});
-      expect(tier).toBe("free");
-    });
-  });
-
-  describe("Tier Matrix Compliance", () => {
-    describe("FREE tier commands", () => {
-      const freeCommands = [
-        "scan", "ship", "install", "init", "doctor", "status", "watch",
-        "ctx", "guard", "context", "mdc", "login", "logout", "whoami", "labs"
-      ];
-
-      test.each(freeCommands)("%s is allowed on FREE tier", async (cmd) => {
-        const result = await enforce(cmd, { silent: true });
-        expect(result.allowed).toBe(true);
-      });
-    });
-
-    describe("STARTER tier commands", () => {
-      const starterCommands = ["gate", "launch", "pr", "badge", "mcp"];
-
-      test.each(starterCommands)("%s requires STARTER+ (blocked on FREE)", async (cmd) => {
-        const result = await enforce(cmd, { silent: true });
-        // Without API key = FREE tier = should be blocked
-        expect(result.allowed).toBe(false);
-        expect(result.requiredTier).toBe("starter");
-        expect(result.exitCode).toBe(EXIT_FEATURE_NOT_ALLOWED);
-      });
-    });
-
-    describe("PRO tier commands", () => {
-      const proCommands = ["prove", "share", "ai-test"];
-
-      test.each(proCommands)("%s requires PRO (blocked on FREE/STARTER)", async (cmd) => {
-        const result = await enforce(cmd, { silent: true });
-        expect(result.allowed).toBe(false);
-        expect(result.requiredTier).toBe("pro");
-        expect(result.exitCode).toBe(EXIT_FEATURE_NOT_ALLOWED);
-      });
-    });
-
-    describe("Subfeature gating", () => {
-      test("fix.plan_only is FREE", async () => {
-        const result = await enforce("fix.plan_only", { silent: true });
-        expect(result.allowed).toBe(true);
-      });
-
-      test("fix.apply_patches requires PRO", async () => {
-        const result = await enforce("fix.apply_patches", { silent: true });
-        expect(result.allowed).toBe(false);
-        expect(result.requiredTier).toBe("pro");
-      });
-
-      test("reality.preview is FREE", async () => {
-        const result = await enforce("reality.preview", { silent: true });
-        expect(result.allowed).toBe(true);
-      });
-
-      test("reality.full requires STARTER", async () => {
-        const result = await enforce("reality.full", { silent: true });
-        expect(result.allowed).toBe(false);
-        expect(result.requiredTier).toBe("starter");
-      });
-
-      test("reality.advanced_auth_boundary requires PRO", async () => {
-        const result = await enforce("reality.advanced_auth_boundary", { silent: true });
-        expect(result.allowed).toBe(false);
-        expect(result.requiredTier).toBe("pro");
-      });
-
-      test("report.html_md is FREE", async () => {
-        const result = await enforce("report.html_md", { silent: true });
-        expect(result.allowed).toBe(true);
-      });
-
-      test("report.sarif_csv requires STARTER", async () => {
-        const result = await enforce("report.sarif_csv", { silent: true });
-        expect(result.allowed).toBe(false);
-        expect(result.requiredTier).toBe("starter");
-      });
-
-      test("report.compliance_packs requires PRO", async () => {
-        const result = await enforce("report.compliance_packs", { silent: true });
-        expect(result.allowed).toBe(false);
-        expect(result.requiredTier).toBe("pro");
-      });
-    });
-  });
-
-  describe("Downgrade Behaviors", () => {
-    test("reality downgrades to reality.preview on FREE", async () => {
-      const result = await enforce("reality", { silent: true });
-      expect(result.allowed).toBe(true);
-      expect(result.downgrade).toBe("reality.preview");
-      expect(result.caps).toBeDefined();
-    });
-
-    test("fix downgrades to fix.plan_only on FREE", async () => {
-      const result = await enforce("fix", { silent: true });
-      expect(result.allowed).toBe(true);
-      expect(result.downgrade).toBe("fix.plan_only");
-    });
-
-    test("report downgrades to report.html_md on FREE", async () => {
-      const result = await enforce("report", { silent: true });
-      expect(result.allowed).toBe(true);
-      expect(result.downgrade).toBe("report.html_md");
-    });
-  });
-
-  describe("Exit Codes", () => {
-    test("Returns EXIT_FEATURE_NOT_ALLOWED (3) for blocked features", async () => {
-      const result = await enforce("prove", { silent: true });
-      expect(result.exitCode).toBe(3);
-      expect(result.exitCode).toBe(EXIT_FEATURE_NOT_ALLOWED);
-    });
-
-    test("Returns EXIT_MISCONFIG (4) for unknown features", async () => {
-      const result = await enforce("nonexistent_feature", { silent: true });
-      expect(result.exitCode).toBe(4);
-      expect(result.exitCode).toBe(EXIT_MISCONFIG);
-    });
-  });
-
-  describe("Limits by Tier", () => {
-    test("FREE tier has correct limits", () => {
-      const limits = getLimits("free");
-      expect(limits.realityMaxPages).toBe(5);
-      expect(limits.realityMaxClicks).toBe(20);
-      expect(limits.realityAuthBoundary).toBe(false);
-      expect(limits.reportFormats).toEqual(["html", "md"]);
-      expect(limits.fixApplyPatches).toBe(false);
-    });
-
-    test("STARTER tier has expanded limits", () => {
-      const limits = getLimits("starter");
-      expect(limits.realityMaxPages).toBe(50);
-      expect(limits.realityAuthBoundary).toBe(true);
-      expect(limits.reportFormats).toContain("sarif");
-      expect(limits.reportFormats).toContain("csv");
-      expect(limits.fixApplyPatches).toBe(false);
-    });
-
-    test("PRO tier has full access", () => {
-      const limits = getLimits("pro");
-      expect(limits.realityMaxPages).toBe(-1); // unlimited
-      expect(limits.realityAdvancedAuth).toBe(true);
-      expect(limits.reportFormats).toContain("compliance");
-      expect(limits.fixApplyPatches).toBe(true);
-    });
-  });
-
-  describe("Tier Comparison Helpers", () => {
-    test("tierMeetsMinimum works correctly", () => {
-      expect(tierMeetsMinimum("free", "free")).toBe(true);
-      expect(tierMeetsMinimum("free", "starter")).toBe(false);
-      expect(tierMeetsMinimum("starter", "free")).toBe(true);
-      expect(tierMeetsMinimum("starter", "starter")).toBe(true);
-      expect(tierMeetsMinimum("starter", "pro")).toBe(false);
-      expect(tierMeetsMinimum("pro", "starter")).toBe(true);
-      expect(tierMeetsMinimum("pro", "pro")).toBe(true);
-      expect(tierMeetsMinimum("enterprise", "pro")).toBe(true);
-    });
-
-    test("getMinTierForFeature returns correct tier", () => {
-      expect(getMinTierForFeature("scan")).toBe("free");
-      expect(getMinTierForFeature("gate")).toBe("starter");
-      expect(getMinTierForFeature("prove")).toBe("pro");
-      expect(getMinTierForFeature("unknown")).toBe("enterprise");
-    });
-
-    test("tierHasFeature returns correct boolean", () => {
-      expect(tierHasFeature("free", "scan")).toBe(true);
-      expect(tierHasFeature("free", "gate")).toBe(false);
-      expect(tierHasFeature("starter", "gate")).toBe(true);
-      expect(tierHasFeature("starter", "prove")).toBe(false);
-      expect(tierHasFeature("pro", "prove")).toBe(true);
-    });
-  });
-
-  describe("ENTITLEMENTS Matrix Validation", () => {
-    test("All required commands are defined", () => {
-      const requiredCommands = [
-        "scan", "ship", "reality", "prove", "fix", "report",
-        "install", "init", "doctor", "status", "watch", "launch",
-        "ctx", "guard", "context", "mdc",
-        "gate", "pr", "badge", "mcp", "share", "ai-test",
-        "login", "logout", "whoami", "labs"
-      ];
-
-      for (const cmd of requiredCommands) {
-        expect(ENTITLEMENTS[cmd]).toBeDefined();
-        expect(ENTITLEMENTS[cmd].minTier).toBeDefined();
-      }
-    });
-
-    test("All tiers are valid", () => {
-      for (const [feature, def] of Object.entries(ENTITLEMENTS)) {
-        expect(TIERS[def.minTier]).toBeDefined();
-      }
-    });
-  });
-});
-
-describe("CLI Help Tier Labels", () => {
-  test("TIERS constant has correct pricing", () => {
-    expect(TIERS.free.price).toBe(0);
-    expect(TIERS.starter.price).toBe(29);
-    expect(TIERS.pro.price).toBe(99);
-    expect(TIERS.enterprise.price).toBe(499);
-  });
-
-  test("TIERS constant has correct order", () => {
-    expect(TIERS.free.order).toBeLessThan(TIERS.starter.order);
-    expect(TIERS.starter.order).toBeLessThan(TIERS.pro.order);
-    expect(TIERS.pro.order).toBeLessThan(TIERS.enterprise.order);
-  });
-});
+/**
+ * Entitlements v2 Tests - Tier Enforcement Verification
+ * 
+ * These tests verify:
+ * 1. No bypass via env vars (VIBECHECK_SKIP_AUTH, VIBECHECK_OWNER, etc.)
+ * 2. Correct tier gating for each command/feature
+ * 3. Proper exit codes (3 = feature not allowed)
+ * 4. Downgrade behaviors work correctly
+ * 5. Help output shows correct tier labels
+ */
+
+const {
+  getTier,
+  getLimits,
+  enforce,
+  checkCommand,
+  tierMeetsMinimum,
+  getMinTierForFeature,
+  tierHasFeature,
+  TIERS,
+  ENTITLEMENTS,
+  LIMITS,
+  EXIT_FEATURE_NOT_ALLOWED,
+  EXIT_MISCONFIG,
+} = require("../entitlements-v2");
+
+describe("Entitlements v2 - Tier Enforcement", () => {
+  // Store original env
+  const originalEnv = { ...process.env };
+  
+  beforeEach(() => {
+    // Reset env before each test
+    process.env = { ...originalEnv };
+    // Clear any env vars that might bypass
+    delete process.env.VIBECHECK_SKIP_AUTH;
+    delete process.env.VIBECHECK_OWNER;
+    delete process.env.VIBECHECK_DEMO;
+    delete process.env.OWNER_MODE;
+  });
+  
+  afterAll(() => {
+    process.env = originalEnv;
+  });
+
+  describe("No Bypass Tests", () => {
+    test("VIBECHECK_SKIP_AUTH does NOT grant paid features", async () => {
+      process.env.VIBECHECK_SKIP_AUTH = "1";
+      
+      // prove is PRO-only
+      const result = await enforce("prove", { silent: true });
+      expect(result.allowed).toBe(false);
+      expect(result.exitCode).toBe(EXIT_FEATURE_NOT_ALLOWED);
+    });
+
+    test("VIBECHECK_OWNER does NOT grant paid features", async () => {
+      process.env.VIBECHECK_OWNER = "1";
+      
+      const result = await enforce("prove", { silent: true });
+      expect(result.allowed).toBe(false);
+    });
+
+    test("VIBECHECK_DEMO does NOT grant paid features", async () => {
+      process.env.VIBECHECK_DEMO = "1";
+      
+      const result = await enforce("ai-test", { silent: true });
+      expect(result.allowed).toBe(false);
+    });
+
+    test("OWNER_MODE does NOT grant paid features", async () => {
+      process.env.OWNER_MODE = "true";
+      
+      const result = await enforce("share", { silent: true });
+      expect(result.allowed).toBe(false);
+    });
+
+    test("Offline mode defaults to FREE tier (no escalation)", async () => {
+      // Without API key, should be FREE
+      const tier = await getTier({});
+      expect(tier).toBe("free");
+    });
+  });
+
+  describe("Tier Matrix Compliance", () => {
+    describe("FREE tier commands", () => {
+      const freeCommands = [
+        "scan", "ship", "install", "init", "doctor", "status", "watch",
+        "ctx", "guard", "context", "mdc", "login", "logout", "whoami", "labs"
+      ];
+
+      test.each(freeCommands)("%s is allowed on FREE tier", async (cmd) => {
+        const result = await enforce(cmd, { silent: true });
+        expect(result.allowed).toBe(true);
+      });
+    });
+
+    describe("STARTER tier commands", () => {
+      const starterCommands = ["gate", "launch", "pr", "badge", "mcp"];
+
+      test.each(starterCommands)("%s requires STARTER+ (blocked on FREE)", async (cmd) => {
+        const result = await enforce(cmd, { silent: true });
+        // Without API key = FREE tier = should be blocked
+        expect(result.allowed).toBe(false);
+        expect(result.requiredTier).toBe("starter");
+        expect(result.exitCode).toBe(EXIT_FEATURE_NOT_ALLOWED);
+      });
+    });
+
+    describe("PRO tier commands", () => {
+      const proCommands = ["prove", "share", "ai-test"];
+
+      test.each(proCommands)("%s requires PRO (blocked on FREE/STARTER)", async (cmd) => {
+        const result = await enforce(cmd, { silent: true });
+        expect(result.allowed).toBe(false);
+        expect(result.requiredTier).toBe("pro");
+        expect(result.exitCode).toBe(EXIT_FEATURE_NOT_ALLOWED);
+      });
+    });
+
+    describe("Subfeature gating", () => {
+      test("fix.plan_only is FREE", async () => {
+        const result = await enforce("fix.plan_only", { silent: true });
+        expect(result.allowed).toBe(true);
+      });
+
+      test("fix.apply_patches requires PRO", async () => {
+        const result = await enforce("fix.apply_patches", { silent: true });
+        expect(result.allowed).toBe(false);
+        expect(result.requiredTier).toBe("pro");
+      });
+
+      test("reality.preview is FREE", async () => {
+        const result = await enforce("reality.preview", { silent: true });
+        expect(result.allowed).toBe(true);
+      });
+
+      test("reality.full requires STARTER", async () => {
+        const result = await enforce("reality.full", { silent: true });
+        expect(result.allowed).toBe(false);
+        expect(result.requiredTier).toBe("starter");
+      });
+
+      test("reality.advanced_auth_boundary requires PRO", async () => {
+        const result = await enforce("reality.advanced_auth_boundary", { silent: true });
+        expect(result.allowed).toBe(false);
+        expect(result.requiredTier).toBe("pro");
+      });
+
+      test("report.html_md is FREE", async () => {
+        const result = await enforce("report.html_md", { silent: true });
+        expect(result.allowed).toBe(true);
+      });
+
+      test("report.sarif_csv requires STARTER", async () => {
+        const result = await enforce("report.sarif_csv", { silent: true });
+        expect(result.allowed).toBe(false);
+        expect(result.requiredTier).toBe("starter");
+      });
+
+      test("report.compliance_packs requires PRO", async () => {
+        const result = await enforce("report.compliance_packs", { silent: true });
+        expect(result.allowed).toBe(false);
+        expect(result.requiredTier).toBe("pro");
+      });
+    });
+  });
+
+  describe("Downgrade Behaviors", () => {
+    test("reality downgrades to reality.preview on FREE", async () => {
+      const result = await enforce("reality", { silent: true });
+      expect(result.allowed).toBe(true);
+      expect(result.downgrade).toBe("reality.preview");
+      expect(result.caps).toBeDefined();
+    });
+
+    test("fix downgrades to fix.plan_only on FREE", async () => {
+      const result = await enforce("fix", { silent: true });
+      expect(result.allowed).toBe(true);
+      expect(result.downgrade).toBe("fix.plan_only");
+    });
+
+    test("report downgrades to report.html_md on FREE", async () => {
+      const result = await enforce("report", { silent: true });
+      expect(result.allowed).toBe(true);
+      expect(result.downgrade).toBe("report.html_md");
+    });
+  });
+
+  describe("Exit Codes", () => {
+    test("Returns EXIT_FEATURE_NOT_ALLOWED (3) for blocked features", async () => {
+      const result = await enforce("prove", { silent: true });
+      expect(result.exitCode).toBe(3);
+      expect(result.exitCode).toBe(EXIT_FEATURE_NOT_ALLOWED);
+    });
+
+    test("Returns EXIT_MISCONFIG (4) for unknown features", async () => {
+      const result = await enforce("nonexistent_feature", { silent: true });
+      expect(result.exitCode).toBe(4);
+      expect(result.exitCode).toBe(EXIT_MISCONFIG);
+    });
+  });
+
+  describe("Limits by Tier", () => {
+    test("FREE tier has correct limits", () => {
+      const limits = getLimits("free");
+      expect(limits.realityMaxPages).toBe(5);
+      expect(limits.realityMaxClicks).toBe(20);
+      expect(limits.realityAuthBoundary).toBe(false);
+      expect(limits.reportFormats).toEqual(["html", "md"]);
+      expect(limits.fixApplyPatches).toBe(false);
+    });
+
+    test("STARTER tier has expanded limits", () => {
+      const limits = getLimits("starter");
+      expect(limits.realityMaxPages).toBe(50);
+      expect(limits.realityAuthBoundary).toBe(true);
+      expect(limits.reportFormats).toContain("sarif");
+      expect(limits.reportFormats).toContain("csv");
+      expect(limits.fixApplyPatches).toBe(false);
+    });
+
+    test("PRO tier has full access", () => {
+      const limits = getLimits("pro");
+      expect(limits.realityMaxPages).toBe(-1); // unlimited
+      expect(limits.realityAdvancedAuth).toBe(true);
+      expect(limits.reportFormats).toContain("compliance");
+      expect(limits.fixApplyPatches).toBe(true);
+    });
+  });
+
+  describe("Tier Comparison Helpers", () => {
+    test("tierMeetsMinimum works correctly", () => {
+      expect(tierMeetsMinimum("free", "free")).toBe(true);
+      expect(tierMeetsMinimum("free", "starter")).toBe(false);
+      expect(tierMeetsMinimum("starter", "free")).toBe(true);
+      expect(tierMeetsMinimum("starter", "starter")).toBe(true);
+      expect(tierMeetsMinimum("starter", "pro")).toBe(false);
+      expect(tierMeetsMinimum("pro", "starter")).toBe(true);
+      expect(tierMeetsMinimum("pro", "pro")).toBe(true);
+      expect(tierMeetsMinimum("enterprise", "pro")).toBe(true);
+    });
+
+    test("getMinTierForFeature returns correct tier", () => {
+      expect(getMinTierForFeature("scan")).toBe("free");
+      expect(getMinTierForFeature("gate")).toBe("starter");
+      expect(getMinTierForFeature("prove")).toBe("pro");
+      expect(getMinTierForFeature("unknown")).toBe("enterprise");
+    });
+
+    test("tierHasFeature returns correct boolean", () => {
+      expect(tierHasFeature("free", "scan")).toBe(true);
+      expect(tierHasFeature("free", "gate")).toBe(false);
+      expect(tierHasFeature("starter", "gate")).toBe(true);
+      expect(tierHasFeature("starter", "prove")).toBe(false);
+      expect(tierHasFeature("pro", "prove")).toBe(true);
+    });
+  });
+
+  describe("ENTITLEMENTS Matrix Validation", () => {
+    test("All required commands are defined", () => {
+      const requiredCommands = [
+        "scan", "ship", "reality", "prove", "fix", "report",
+        "install", "init", "doctor", "status", "watch", "launch",
+        "ctx", "guard", "context", "mdc",
+        "gate", "pr", "badge", "mcp", "share", "ai-test",
+        "login", "logout", "whoami", "labs"
+      ];
+
+      for (const cmd of requiredCommands) {
+        expect(ENTITLEMENTS[cmd]).toBeDefined();
+        expect(ENTITLEMENTS[cmd].minTier).toBeDefined();
+      }
+    });
+
+    test("All tiers are valid", () => {
+      for (const [feature, def] of Object.entries(ENTITLEMENTS)) {
+        expect(TIERS[def.minTier]).toBeDefined();
+      }
+    });
+  });
+});
+
+describe("CLI Help Tier Labels", () => {
+  test("TIERS constant has correct pricing", () => {
+    expect(TIERS.free.price).toBe(0);
+    expect(TIERS.starter.price).toBe(29);
+    expect(TIERS.pro.price).toBe(99);
+    expect(TIERS.enterprise.price).toBe(499);
+  });
+
+  test("TIERS constant has correct order", () => {
+    expect(TIERS.free.order).toBeLessThan(TIERS.starter.order);
+    expect(TIERS.starter.order).toBeLessThan(TIERS.pro.order);
+    expect(TIERS.pro.order).toBeLessThan(TIERS.enterprise.order);
+  });
+});