@checkstack/slo-backend 0.2.4 → 0.2.5

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @checkstack/slo-backend
 
+## 0.2.5
+
+### Patch Changes
+
+- 86bab6a: ### GitOps: Fix authentication token handling
+
+  - Made `authToken` optional in `ReconcileProviderParams` and `ScraperOptions` to support unauthenticated access to public repositories
+  - GitHub and GitLab scrapers now conditionally set authentication headers only when a token is provided
+  - Sync worker now decrypts the encrypted `authToken` from the database before passing it to scrapers, fixing authentication failures caused by sending encrypted values in HTTP headers
+
+  ### SLO: Fix premature Nines Club achievement unlock
+
+  - The "Nines Club" achievement now requires both ≥99.99% availability **and** a 365-day compliance streak, preventing immediate unlock on newly created SLOs with 100% default availability
+
+  ### SLO: Align frontend achievement descriptions with backend criteria
+
+  - Fixed mismatched descriptions for Iron Uptime (7-day, not 30), Diamond Uptime (30-day, not 90), Clean Sheet (rolling window, not quarter), Full Coverage (3+ SLOs, not all systems in group), and Nines Club (99.99%)
+
+  ### SLO: Enrich milestones with system names
+
+  - The `getRecentMilestones` endpoint now resolves human-readable system names via the Catalog API instead of returning raw system IDs
+  - @checkstack/catalog-backend@0.4.1
+  - @checkstack/healthcheck-backend@0.14.2
+
 ## 0.2.4
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/slo-backend",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "type": "module",
   "main": "src/index.ts",
   "checkstack": {
@@ -16,10 +16,10 @@
     "@checkstack/backend-api": "0.12.0",
     "@checkstack/slo-common": "0.2.0",
     "@checkstack/healthcheck-common": "0.11.0",
-    "@checkstack/healthcheck-backend": "0.13.1",
+    "@checkstack/healthcheck-backend": "0.14.1",
     "@checkstack/dependency-common": "0.2.1",
     "@checkstack/catalog-common": "1.3.1",
-    "@checkstack/catalog-backend": "0.2.24",
+    "@checkstack/catalog-backend": "0.4.0",
     "@checkstack/command-backend": "0.1.19",
     "@checkstack/signal-common": "0.1.9",
     "@checkstack/integration-backend": "0.1.19",

package/src/achievement-evaluator.test.ts

@@ -0,0 +1,219 @@
+import { describe, it, expect } from "bun:test";
+import {
+  ACHIEVEMENT_DEFINITIONS,
+  type AchievementContext,
+} from "./achievement-evaluator";
+
+/**
+ * Creates a base context with sensible defaults for testing.
+ * All achievements should be OFF with these defaults.
+ */
+function baseContext(
+  overrides?: Partial<AchievementContext>,
+): AchievementContext {
+  return {
+    objectiveCount: 0,
+    streakDays: 0,
+    bestAvailability: undefined,
+    budgetRemainingPercent: undefined,
+    hasZeroDowntime: false,
+    hasUpstreamOnlyDowntime: false,
+    fastestRecoverySeconds: undefined,
+    ...overrides,
+  };
+}
+
+function findDefinition(type: string) {
+  const def = ACHIEVEMENT_DEFINITIONS.find((d) => d.type === type);
+  if (!def) throw new Error(`Achievement definition not found: ${type}`);
+  return def;
+}
+
+describe("achievement definitions", () => {
+  describe("nines_club", () => {
+    const ninesClub = findDefinition("nines_club");
+
+    it("requires both 99.99% availability AND 365-day streak", () => {
+      const ctx = baseContext({
+        bestAvailability: 99.995,
+        streakDays: 365,
+      });
+      expect(ninesClub.evaluate(ctx)).toBe(true);
+    });
+
+    it("does NOT unlock with high availability but insufficient streak", () => {
+      const ctx = baseContext({
+        bestAvailability: 99.999,
+        streakDays: 30,
+      });
+      expect(ninesClub.evaluate(ctx)).toBe(false);
+    });
+
+    it("does NOT unlock with 365-day streak but low availability", () => {
+      const ctx = baseContext({
+        bestAvailability: 99.98,
+        streakDays: 400,
+      });
+      expect(ninesClub.evaluate(ctx)).toBe(false);
+    });
+
+    it("does NOT unlock with undefined availability even with long streak", () => {
+      const ctx = baseContext({
+        bestAvailability: undefined,
+        streakDays: 500,
+      });
+      expect(ninesClub.evaluate(ctx)).toBe(false);
+    });
+
+    it("does NOT unlock on a freshly created SLO (zero streak, 100% availability)", () => {
+      const ctx = baseContext({
+        bestAvailability: 100.0,
+        streakDays: 0,
+      });
+      expect(ninesClub.evaluate(ctx)).toBe(false);
+    });
+  });
+
+  describe("iron_uptime", () => {
+    const ironUptime = findDefinition("iron_uptime");
+
+    it("unlocks at 7-day streak", () => {
+      expect(ironUptime.evaluate(baseContext({ streakDays: 7 }))).toBe(true);
+    });
+
+    it("does NOT unlock below 7 days", () => {
+      expect(ironUptime.evaluate(baseContext({ streakDays: 6 }))).toBe(false);
+    });
+  });
+
+  describe("diamond_uptime", () => {
+    const diamondUptime = findDefinition("diamond_uptime");
+
+    it("unlocks at 30-day streak", () => {
+      expect(diamondUptime.evaluate(baseContext({ streakDays: 30 }))).toBe(
+        true,
+      );
+    });
+
+    it("does NOT unlock below 30 days", () => {
+      expect(diamondUptime.evaluate(baseContext({ streakDays: 29 }))).toBe(
+        false,
+      );
+    });
+  });
+
+  describe("first_steps", () => {
+    const firstSteps = findDefinition("first_steps");
+
+    it("unlocks with 1 objective", () => {
+      expect(firstSteps.evaluate(baseContext({ objectiveCount: 1 }))).toBe(
+        true,
+      );
+    });
+
+    it("does NOT unlock with 0 objectives", () => {
+      expect(firstSteps.evaluate(baseContext({ objectiveCount: 0 }))).toBe(
+        false,
+      );
+    });
+  });
+
+  describe("full_coverage", () => {
+    const fullCoverage = findDefinition("full_coverage");
+
+    it("unlocks with 3 or more objectives", () => {
+      expect(fullCoverage.evaluate(baseContext({ objectiveCount: 3 }))).toBe(
+        true,
+      );
+      expect(fullCoverage.evaluate(baseContext({ objectiveCount: 5 }))).toBe(
+        true,
+      );
+    });
+
+    it("does NOT unlock with fewer than 3 objectives", () => {
+      expect(fullCoverage.evaluate(baseContext({ objectiveCount: 2 }))).toBe(
+        false,
+      );
+    });
+  });
+
+  describe("budget_miser", () => {
+    const budgetMiser = findDefinition("budget_miser");
+
+    it("unlocks when 90% or more budget remaining", () => {
+      expect(
+        budgetMiser.evaluate(baseContext({ budgetRemainingPercent: 90 })),
+      ).toBe(true);
+      expect(
+        budgetMiser.evaluate(baseContext({ budgetRemainingPercent: 99 })),
+      ).toBe(true);
+    });
+
+    it("does NOT unlock below 90% remaining", () => {
+      expect(
+        budgetMiser.evaluate(baseContext({ budgetRemainingPercent: 89.9 })),
+      ).toBe(false);
+    });
+
+    it("does NOT unlock with undefined budget", () => {
+      expect(
+        budgetMiser.evaluate(baseContext({ budgetRemainingPercent: undefined })),
+      ).toBe(false);
+    });
+  });
+
+  describe("clean_sheet", () => {
+    const cleanSheet = findDefinition("clean_sheet");
+
+    it("unlocks with zero downtime", () => {
+      expect(cleanSheet.evaluate(baseContext({ hasZeroDowntime: true }))).toBe(
+        true,
+      );
+    });
+
+    it("does NOT unlock when downtime has occurred", () => {
+      expect(cleanSheet.evaluate(baseContext({ hasZeroDowntime: false }))).toBe(
+        false,
+      );
+    });
+  });
+
+  describe("cascade_breaker", () => {
+    const cascadeBreaker = findDefinition("cascade_breaker");
+
+    it("unlocks when all downtime is upstream-attributed", () => {
+      expect(
+        cascadeBreaker.evaluate(
+          baseContext({ hasUpstreamOnlyDowntime: true }),
+        ),
+      ).toBe(true);
+    });
+
+    it("does NOT unlock without upstream-only downtime", () => {
+      expect(
+        cascadeBreaker.evaluate(
+          baseContext({ hasUpstreamOnlyDowntime: false }),
+        ),
+      ).toBe(false);
+    });
+  });
+
+  describe("rapid_recovery", () => {
+    const rapidRecovery = findDefinition("rapid_recovery");
+
+    it("unlocks with 5-minute or under recovery", () => {
+      expect(
+        rapidRecovery.evaluate(baseContext({ fastestRecoverySeconds: 300 })),
+      ).toBe(true);
+      expect(
+        rapidRecovery.evaluate(baseContext({ fastestRecoverySeconds: 60 })),
+      ).toBe(true);
+    });
+
+    it("does NOT unlock over 5 minutes", () => {
+      expect(
+        rapidRecovery.evaluate(baseContext({ fastestRecoverySeconds: 301 })),
+      ).toBe(false);
+    });
+  });
+});

package/src/achievement-evaluator.ts

@@ -34,9 +34,9 @@ const ACHIEVEMENT_DEFINITIONS: Array<{
   },
   {
     type: "nines_club",
-    description: "Achieved 99.9% or higher availability in a rolling window",
-    evaluate: ({ bestAvailability }) =>
-      bestAvailability !== undefined && bestAvailability >= 99.9,
+    description: "Maintained 99.99% or higher availability for 365 days",
+    evaluate: ({ bestAvailability, streakDays }) =>
+      bestAvailability !== undefined && bestAvailability >= 99.99 && streakDays >= 365,
   },
   {
     type: "budget_miser",
@@ -199,3 +199,7 @@ export function getAchievementDefinitions() {
     description: d.description,
   }));
 }
+
+// Export for testing
+export { ACHIEVEMENT_DEFINITIONS };
+export type { AchievementContext };

package/src/index.ts

@@ -177,7 +177,7 @@ export default createBackendPlugin({
         rpcClient: coreServices.rpcClient,
         queueManager: coreServices.queueManager,
       },
-      init: async ({ logger, database, rpc, signalService }) => {
+      init: async ({ logger, database, rpc, signalService, rpcClient }) => {
         logger.debug("🔧 Initializing SLO Backend...");
 
         const service = new SloService(database as SafeDatabase<typeof schema>);
@@ -190,7 +190,7 @@ export default createBackendPlugin({
         // Store for afterPluginsReady
         sharedEngine = engine;
 
-        const router = createRouter({ service, engine, signalService });
+        const router = createRouter({ service, engine, signalService, rpcClient });
         rpc.registerRouter(router, sloContract);
 
         // Register command palette entries

package/src/router.ts

@@ -6,8 +6,10 @@ import {
 import {
   autoAuthMiddleware,
   type RpcContext,
+  type RpcClient,
 } from "@checkstack/backend-api";
 import type { SignalService } from "@checkstack/signal-common";
+import { CatalogApi } from "@checkstack/catalog-common";
 import type { SloService } from "./service";
 import type { SloEngine } from "./slo-engine";
 
@@ -15,10 +17,12 @@ export function createRouter({
   service,
   engine,
   signalService,
+  rpcClient,
 }: {
   service: SloService;
   engine: SloEngine;
   signalService: SignalService;
+  rpcClient: RpcClient;
 }) {
   const os = implement(sloContract)
     .$context<RpcContext>()
@@ -180,9 +184,30 @@ export function createRouter({
       const achievements = await service.getRecentMilestones({
         limit: input.limit ?? 20,
       });
+
+      // Collect unique system IDs for batch lookup
+      const uniqueSystemIds = [...new Set(achievements.map((a) => a.systemId))];
+      const systemNameMap = new Map<string, string>();
+
+      // Resolve system names via catalog RPC
+      const catalogClient = rpcClient.forPlugin(CatalogApi);
+      await Promise.all(
+        uniqueSystemIds.map(async (systemId) => {
+          try {
+            const system = await catalogClient.getSystem({ systemId });
+            if (system?.name) {
+              systemNameMap.set(systemId, system.name);
+            }
+          } catch {
+            // Silently skip — system may have been deleted
+          }
+        }),
+      );
+
       return {
         milestones: achievements.map((a) => ({
           systemId: a.systemId,
+          systemName: systemNameMap.get(a.systemId),
           achievement: a.achievement,
           unlockedAt: a.unlockedAt,
         })),