stagent 0.9.5 → 0.10.0

package/src/lib/license/__tests__/manager.test.ts

@@ -1,64 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { eq } from "drizzle-orm";
-import { db } from "@/lib/db";
-import { license as licenseTable } from "@/lib/db/schema";
-import { licenseManager } from "../manager";
-
-const LICENSE_ROW_ID = "default";
-
-/**
- * Regression: under Turbopack module instance separation, the singleton's
- * in-memory cache could disagree with the DB. If another module instance
- * (or another process) updates the license row, getTier() must reflect
- * the new value — otherwise gated limits silently fall back to community
- * tier rules even on paid tiers.
- *
- * The fix in manager.ts makes getTier() / getStatus() read from the DB.
- * This test simulates the cross-instance scenario by mutating the DB row
- * directly without going through licenseManager.activate().
- */
-describe("LicenseManager — DB-direct tier reads", () => {
-  beforeEach(() => {
-    // Reset to a known community baseline.
-    db.delete(licenseTable).where(eq(licenseTable.id, LICENSE_ROW_ID)).run();
-    licenseManager.initialize();
-  });
-
-  afterEach(() => {
-    db.delete(licenseTable).where(eq(licenseTable.id, LICENSE_ROW_ID)).run();
-  });
-
-  it("getTier() reflects DB updates that bypassed activate()", () => {
-    expect(licenseManager.getTier()).toBe("community");
-
-    // Simulate "another module instance wrote scale to the DB".
-    db.update(licenseTable)
-      .set({ tier: "scale", status: "active", updatedAt: new Date() })
-      .where(eq(licenseTable.id, LICENSE_ROW_ID))
-      .run();
-
-    expect(licenseManager.getTier()).toBe("scale");
-    expect(licenseManager.getLimit("agentMemories")).toBe(Infinity);
-    expect(licenseManager.getLimit("activeSchedules")).toBe(Infinity);
-    expect(licenseManager.getLimit("parallelWorkflows")).toBe(Infinity);
-    expect(licenseManager.isPremium()).toBe(true);
-  });
-
-  it("getStatus() also reads from DB, not stale cache", () => {
-    expect(licenseManager.getStatus().tier).toBe("community");
-
-    db.update(licenseTable)
-      .set({
-        tier: "operator",
-        status: "active",
-        email: "ops@example.com",
-        updatedAt: new Date(),
-      })
-      .where(eq(licenseTable.id, LICENSE_ROW_ID))
-      .run();
-
-    const status = licenseManager.getStatus();
-    expect(status.tier).toBe("operator");
-    expect(status.email).toBe("ops@example.com");
-  });
-});

package/src/lib/license/__tests__/tier-limits.test.ts

@@ -1,79 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  TIERS,
-  TIER_RANK,
-  TIER_LIMITS,
-  TIER_LABELS,
-  TIER_PRICING,
-  type LicenseTier,
-  type LimitResource,
-} from "../tier-limits";
-
-describe("tier-limits", () => {
-  it("defines all four tiers", () => {
-    expect(TIERS).toEqual(["community", "solo", "operator", "scale"]);
-  });
-
-  it("ranks tiers in ascending order", () => {
-    expect(TIER_RANK.community).toBeLessThan(TIER_RANK.solo);
-    expect(TIER_RANK.solo).toBeLessThan(TIER_RANK.operator);
-    expect(TIER_RANK.operator).toBeLessThan(TIER_RANK.scale);
-  });
-
-  it("all limit resources are defined for every tier", () => {
-    const resources: LimitResource[] = [
-      "agentMemories",
-      "contextVersions",
-      "activeSchedules",
-      "historyRetentionDays",
-      "parallelWorkflows",
-    ];
-    for (const tier of TIERS) {
-      for (const resource of resources) {
-        expect(TIER_LIMITS[tier][resource]).toBeDefined();
-        expect(typeof TIER_LIMITS[tier][resource]).toBe("number");
-      }
-    }
-  });
-
-  it("higher tiers have equal or greater limits", () => {
-    const tierOrder: LicenseTier[] = ["community", "solo", "operator", "scale"];
-    for (let i = 1; i < tierOrder.length; i++) {
-      const current = tierOrder[i];
-      const previous = tierOrder[i - 1];
-      for (const resource of Object.keys(TIER_LIMITS[current]) as LimitResource[]) {
-        expect(TIER_LIMITS[current][resource]).toBeGreaterThanOrEqual(
-          TIER_LIMITS[previous][resource]
-        );
-      }
-    }
-  });
-
-  it("scale tier has Infinity for all resources", () => {
-    for (const value of Object.values(TIER_LIMITS.scale)) {
-      expect(value).toBe(Infinity);
-    }
-  });
-
-  it("community tier has finite limits", () => {
-    for (const value of Object.values(TIER_LIMITS.community)) {
-      expect(Number.isFinite(value)).toBe(true);
-    }
-  });
-
-  it("labels exist for all tiers", () => {
-    for (const tier of TIERS) {
-      expect(TIER_LABELS[tier]).toBeTruthy();
-    }
-  });
-
-  it("pricing exists for all tiers with annual < 12x monthly", () => {
-    for (const tier of TIERS) {
-      const { monthly, annual } = TIER_PRICING[tier];
-      expect(monthly).toBeGreaterThanOrEqual(0);
-      if (monthly > 0) {
-        expect(annual).toBeLessThan(monthly * 12);
-      }
-    }
-  });
-});

package/src/lib/license/cloud-validation.ts

@@ -1,60 +0,0 @@
-/**
- * Cloud license validation via Supabase Edge Function.
- *
- * Calls the validate-license Edge Function to check if the user's
- * email has an active subscription. Uses the same Supabase client
- * defaults as supabase-client.ts (production backend by default).
- */
-
-import { isCloudConfigured, getSupabaseUrl, getSupabaseAnonKey } from "@/lib/cloud/supabase-client";
-import type { LicenseTier } from "./tier-limits";
-
-export interface CloudValidationResult {
-  valid: boolean;
-  tier: LicenseTier;
-  expiresAt?: Date;
-  error?: string;
-}
-
-/**
- * Validate a license against the cloud backend.
- * Returns { valid: false } if cloud is disabled or email is empty.
- */
-export async function validateLicenseWithCloud(
-  email: string
-): Promise<CloudValidationResult> {
-  if (!isCloudConfigured() || !email) {
-    return { valid: false, tier: "community", error: "Cloud disabled or no email" };
-  }
-
-  const supabaseUrl = getSupabaseUrl();
-  const anonKey = getSupabaseAnonKey();
-
-  try {
-    const response = await fetch(`${supabaseUrl}/functions/v1/validate-license`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${anonKey}`,
-      },
-      body: JSON.stringify({ email }),
-    });
-
-    if (!response.ok) {
-      return { valid: false, tier: "community", error: `HTTP ${response.status}` };
-    }
-
-    const data = await response.json();
-    return {
-      valid: data.valid === true,
-      tier: data.tier ?? "community",
-      expiresAt: data.expiresAt ? new Date(data.expiresAt) : undefined,
-    };
-  } catch (err) {
-    return {
-      valid: false,
-      tier: "community",
-      error: err instanceof Error ? err.message : "Unknown error",
-    };
-  }
-}

package/src/lib/license/features.ts

@@ -1,44 +0,0 @@
-/**
- * Feature→tier gating map.
- *
- * Each feature has a minimum tier required to access it.
- * Use LicenseManager.isFeatureAllowed(feature) to check access.
- */
-
-import { type LicenseTier, TIER_RANK } from "./tier-limits";
-
-export const LICENSE_FEATURES = [
-  "analytics",
-  "cloud-sync",
-  "marketplace-browse",
-  "marketplace-import",
-  "marketplace-publish",
-  "marketplace-featured",
-  "telemetry-benchmarks",
-  "advanced-history",
-  "priority-support",
-] as const;
-
-export type LicenseFeature = (typeof LICENSE_FEATURES)[number];
-
-/** Minimum tier required to access each feature */
-const FEATURE_MIN_TIER: Record<LicenseFeature, LicenseTier> = {
-  "analytics": "operator",
-  "cloud-sync": "operator",
-  "marketplace-browse": "community",
-  "marketplace-import": "solo",
-  "marketplace-publish": "operator",
-  "marketplace-featured": "scale",
-  "telemetry-benchmarks": "solo",
-  "advanced-history": "solo",
-  "priority-support": "scale",
-} as const;
-
-/**
- * Check if a tier can access a feature.
- * Pure function — no side effects or DB access.
- */
-export function canAccessFeature(tier: LicenseTier, feature: LicenseFeature): boolean {
-  const minTier = FEATURE_MIN_TIER[feature];
-  return TIER_RANK[tier] >= TIER_RANK[minTier];
-}

package/src/lib/license/key-format.ts

@@ -1,101 +0,0 @@
-/**
- * License key format: STAG-XXXX-XXXX-XXXX-XXXX
- *
- * - 16 characters from an unambiguous alphabet (no 0/O, 1/I/L)
- * - Last 2 characters are a CRC-16 checksum
- * - Keys are always uppercase
- */
-
-// Unambiguous character set (no 0, O, 1, I, L)
-const ALPHABET = "ABCDEFGHJKMNPQRSTUVWXYZ23456789";
-
-/**
- * Compute a simple CRC-16 checksum for a string.
- */
-function crc16(input: string): number {
-  let crc = 0xffff;
-  for (let i = 0; i < input.length; i++) {
-    crc ^= input.charCodeAt(i) << 8;
-    for (let j = 0; j < 8; j++) {
-      if (crc & 0x8000) {
-        crc = ((crc << 1) ^ 0x1021) & 0xffff;
-      } else {
-        crc = (crc << 1) & 0xffff;
-      }
-    }
-  }
-  return crc;
-}
-
-/**
- * Generate a license key: STAG-XXXX-XXXX-XXXX-XXXX
- * The last 2 characters encode the CRC-16 checksum.
- */
-export function generateLicenseKey(): string {
-  const chars: string[] = [];
-  for (let i = 0; i < 14; i++) {
-    chars.push(ALPHABET[Math.floor(Math.random() * ALPHABET.length)]);
-  }
-
-  const payload = chars.join("");
-  const checksum = crc16(payload);
-
-  // Encode checksum as 2 characters from alphabet
-  const c1 = ALPHABET[checksum % ALPHABET.length];
-  const c2 = ALPHABET[Math.floor(checksum / ALPHABET.length) % ALPHABET.length];
-  chars.push(c1, c2);
-
-  // Format as STAG-XXXX-XXXX-XXXX-XXXX
-  const raw = chars.join("");
-  return `STAG-${raw.slice(0, 4)}-${raw.slice(4, 8)}-${raw.slice(8, 12)}-${raw.slice(12, 16)}`;
-}
-
-/**
- * Validate a license key format and checksum.
- * Returns true if the key is well-formed and the checksum matches.
- */
-export function validateLicenseKey(key: string): { valid: boolean; error?: string } {
-  const normalized = key.toUpperCase().trim();
-
-  // Check format
-  const pattern = /^STAG-[A-HJ-NP-Z2-9]{4}-[A-HJ-NP-Z2-9]{4}-[A-HJ-NP-Z2-9]{4}-[A-HJ-NP-Z2-9]{4}$/;
-  if (!pattern.test(normalized)) {
-    return { valid: false, error: "Invalid format (expected STAG-XXXX-XXXX-XXXX-XXXX)" };
-  }
-
-  // Extract raw characters (remove STAG- prefix and dashes)
-  const raw = normalized.replace(/^STAG-/, "").replace(/-/g, "");
-  if (raw.length !== 16) {
-    return { valid: false, error: "Invalid key length" };
-  }
-
-  // Verify checksum
-  const payload = raw.slice(0, 14);
-  const checksum = crc16(payload);
-  const c1 = ALPHABET[checksum % ALPHABET.length];
-  const c2 = ALPHABET[Math.floor(checksum / ALPHABET.length) % ALPHABET.length];
-
-  if (raw[14] !== c1 || raw[15] !== c2) {
-    return { valid: false, error: "Invalid checksum" };
-  }
-
-  return { valid: true };
-}
-
-/**
- * Auto-format a partial key input with dashes.
- * Converts lowercase and strips invalid characters.
- */
-export function formatKeyInput(input: string): string {
-  // Strip everything except alphanumeric
-  const clean = input.toUpperCase().replace(/[^A-HJ-NP-Z2-9]/g, "");
-
-  // Add STAG- prefix if not present
-  const parts: string[] = [];
-  for (let i = 0; i < clean.length && i < 16; i += 4) {
-    parts.push(clean.slice(i, i + 4));
-  }
-
-  if (parts.length === 0) return "";
-  return "STAG-" + parts.join("-");
-}

package/src/lib/license/limit-check.ts

@@ -1,111 +0,0 @@
-/**
- * Shared limit enforcement helpers.
- *
- * Used by API routes and internal write sites to check tier limits
- * before allowing operations. Returns a structured result for
- * consistent 402 response formatting.
- */
-
-import { licenseManager } from "./manager";
-import { TIER_LIMITS, type LimitResource, TIER_LABELS } from "./tier-limits";
-import { createTierLimitNotification } from "./notifications";
-import { sendMemoryWarning } from "@/lib/billing/email";
-import { trackConversionEvent } from "@/lib/telemetry/conversion-events";
-
-export interface LimitCheckResult {
-  allowed: boolean;
-  current: number;
-  limit: number;
-  tier: string;
-  requiredTier: string;
-}
-
-/**
- * Check if an operation is within the current tier's limit.
- *
- * @param resource - The limit resource key
- * @param currentCount - Current usage count
- * @returns Result with allowed flag and metadata for 402 responses
- */
-export function checkLimit(
-  resource: LimitResource,
-  currentCount: number
-): LimitCheckResult {
-  const tier = licenseManager.getTier();
-  const limit = TIER_LIMITS[tier][resource];
-
-  if (currentCount < limit) {
-    return {
-      allowed: true,
-      current: currentCount,
-      limit: limit === Infinity ? -1 : limit,
-      tier,
-      requiredTier: tier,
-    };
-  }
-
-  // Find the next tier that allows more
-  const tiers = ["community", "solo", "operator", "scale"] as const;
-  const tierIndex = tiers.indexOf(tier);
-  let requiredTier = "scale";
-  for (let i = tierIndex + 1; i < tiers.length; i++) {
-    if (TIER_LIMITS[tiers[i]][resource] > currentCount) {
-      requiredTier = tiers[i];
-      break;
-    }
-  }
-
-  return {
-    allowed: false,
-    current: currentCount,
-    limit: limit === Infinity ? -1 : limit,
-    tier,
-    requiredTier,
-  };
-}
-
-/**
- * Check a limit and emit a tier_limit notification if blocked.
- * Convenience wrapper that combines checkLimit + notification.
- */
-export async function checkLimitAndNotify(
-  resource: LimitResource,
-  currentCount: number,
-  taskId?: string
-): Promise<LimitCheckResult> {
-  const result = checkLimit(resource, currentCount);
-  if (!result.allowed) {
-    await createTierLimitNotification(resource, currentCount, result.limit, taskId);
-    trackConversionEvent("limit_hit", resource, { current: currentCount, limit: result.limit });
-  }
-
-  // Send email warning when approaching memory limit (75%+)
-  if (resource === "agentMemories" && result.allowed && result.limit > 0) {
-    const ratio = currentCount / result.limit;
-    if (ratio >= 0.75) {
-      const email = licenseManager.getStatus().email;
-      if (email) {
-        sendMemoryWarning(email, "agent", currentCount, result.limit).catch(() => {});
-      }
-    }
-  }
-
-  return result;
-}
-
-/**
- * Build a standard 402 response body for limit violations.
- */
-export function buildLimitErrorBody(
-  resource: LimitResource,
-  result: LimitCheckResult
-): Record<string, unknown> {
-  return {
-    error: `${TIER_LABELS[result.tier as keyof typeof TIER_LABELS] ?? result.tier} tier limit reached for ${resource}`,
-    upgradeUrl: "/settings",
-    requiredTier: result.requiredTier,
-    limitType: resource,
-    current: result.current,
-    max: result.limit,
-  };
-}

package/src/lib/license/limit-queries.ts

@@ -1,51 +0,0 @@
-/**
- * Count queries for tier limit enforcement.
- *
- * Each function returns the current count for a specific resource,
- * used with checkLimit() to determine if an operation is allowed.
- */
-
-import { db } from "@/lib/db";
-import { agentMemory, learnedContext, schedules } from "@/lib/db/schema";
-import { eq, and, sql } from "drizzle-orm";
-
-/**
- * Count active (non-archived) memories for a profile.
- */
-export function getMemoryCount(profileId: string): number {
-  const result = db
-    .select({ count: sql<number>`count(*)` })
-    .from(agentMemory)
-    .where(
-      and(
-        eq(agentMemory.profileId, profileId),
-        eq(agentMemory.status, "active")
-      )
-    )
-    .get();
-  return result?.count ?? 0;
-}
-
-/**
- * Count learned context versions for a profile.
- */
-export function getContextVersionCount(profileId: string): number {
-  const result = db
-    .select({ count: sql<number>`count(*)` })
-    .from(learnedContext)
-    .where(eq(learnedContext.profileId, profileId))
-    .get();
-  return result?.count ?? 0;
-}
-
-/**
- * Count active schedules (both scheduled and heartbeat types).
- */
-export function getActiveScheduleCount(): number {
-  const result = db
-    .select({ count: sql<number>`count(*)` })
-    .from(schedules)
-    .where(eq(schedules.status, "active"))
-    .get();
-  return result?.count ?? 0;
-}