mergen-server 1.4.0

package/dist/__stubs__/closed-source.js

@@ -0,0 +1,150 @@
+import { Router } from "express";
+const r = Router();
+const noop = () => {
+};
+const noopAsync = () => Promise.resolve();
+const billingRouter = r;
+const teamRouter = r;
+const initTeam = noopAsync;
+const broadcastToTeam = noop;
+const initUsage = noopAsync;
+const flushOverageOnShutdown = noopAsync;
+const initLicense = noopAsync;
+const initTelemetry = noopAsync;
+const maybeSendTelemetry = noopAsync;
+const uploadCalibrationBatch = noopAsync;
+const getActivePlanId = () => "free";
+const getPlan = () => ({ bufferSize: 2e3, name: "free" });
+const _PLAN_RANK = {
+  free: 0,
+  starter: 1,
+  solo_starter: 1,
+  team: 2,
+  solo_pro: 2,
+  platform: 3,
+  solo_power: 3,
+  enterprise: 4,
+  pay_as_you_go: 4
+};
+const _rank = (planId) => _PLAN_RANK[planId ?? ""] ?? 0;
+const _minRankForGate = (gate) => gate === "free" || gate === "all" ? 0 : gate === "pro" ? 1 : _PLAN_RANK[gate] ?? 0;
+const PLAN_ORDER = ["free", "starter", "team", "platform", "enterprise"];
+const getPlanRank = (planId) => _rank(planId);
+const planMeetsMin = (planId, minPlanId) => _rank(planId) >= _rank(minPlanId);
+const minPlanForGate = (gate) => gate === "free" || gate === "all" ? "free" : gate === "pro" ? "starter" : gate;
+const planAllowsGate = (planId, gate) => _rank(planId) >= _minRankForGate(gate);
+const planHasCapability = (_planId, _cap) => false;
+const planAllowsTier = (planId, tier) => planAllowsGate(planId, tier);
+const getIncidentCount = () => 0;
+const getUsageSnapshot = () => ({});
+const recordExplainWhyFeedback = noopAsync;
+const getTeamState = () => ({ members: [] });
+const isTeamEnabled = () => false;
+const getTelemetryState = () => ({ enabled: false, installId: "stub" });
+const setTelemetryEnabled = noopAsync;
+const registerTools = noop;
+const toolCallCounts = {};
+const lastMcpCallAt = null;
+const firstAnalyzeAt = null;
+const lastTimeToFirstAnalysisMs = null;
+const hypothesisHistory = {
+  list: () => [],
+  latest: () => null,
+  clear: noop,
+  notifyError: noop,
+  add: noop,
+  size: () => 0,
+  _rebuildNowForTesting: noopAsync
+};
+const getStats = () => null;
+const getRecords = () => [];
+const recordVerdict = noop;
+const getStatsForTag = () => null;
+const listActiveSessions = () => [];
+const SYSTEM_PROMPT = "";
+const analyzeCommit = noopAsync;
+const postPRComment = noopAsync;
+const analyzePRShadow = noopAsync;
+const getSessionMetrics = () => ({});
+const getUnclassified = () => [];
+const slackRoutingRouter = r;
+const getLicenseState = () => ({});
+const activateKey = (_key) => Promise.resolve({});
+const deactivateKey = noopAsync;
+const planFromVariantId = (_v) => "free";
+const PLANS = { free: { bufferSize: 2e3, name: "free", backendObservability: true } };
+const consumeCredit = () => Promise.resolve({ allowed: true });
+const consumeIncident = () => Promise.resolve({ allowed: true });
+const recordExplainWhy = noop;
+const _resetForTesting = noop;
+const _setSleepForTesting = noop;
+const computeAnomaly = () => Promise.resolve({ summary: "" });
+const getAnomalousPatterns = () => Promise.resolve([]);
+const computeErrorFrequency = (_logs) => [];
+const computeNetworkFrequency = (_net) => [];
+const normaliseMessage = (msg) => msg;
+const scoreToConfidence = (score) => score >= 0.8 ? "high" : score >= 0.5 ? "medium" : "low";
+const generateReproSteps = () => ({ confidence: "low", markdown: "", steps: [] });
+export {
+  PLANS,
+  PLAN_ORDER,
+  SYSTEM_PROMPT,
+  _resetForTesting,
+  _setSleepForTesting,
+  activateKey,
+  analyzeCommit,
+  analyzePRShadow,
+  billingRouter,
+  broadcastToTeam,
+  computeAnomaly,
+  computeErrorFrequency,
+  computeNetworkFrequency,
+  consumeCredit,
+  consumeIncident,
+  deactivateKey,
+  firstAnalyzeAt,
+  flushOverageOnShutdown,
+  generateReproSteps,
+  getActivePlanId,
+  getAnomalousPatterns,
+  getIncidentCount,
+  getLicenseState,
+  getPlan,
+  getPlanRank,
+  getRecords,
+  getSessionMetrics,
+  getStats,
+  getStatsForTag,
+  getTeamState,
+  getTelemetryState,
+  getUnclassified,
+  getUsageSnapshot,
+  hypothesisHistory,
+  initLicense,
+  initTeam,
+  initTelemetry,
+  initUsage,
+  isTeamEnabled,
+  lastMcpCallAt,
+  lastTimeToFirstAnalysisMs,
+  listActiveSessions,
+  maybeSendTelemetry,
+  minPlanForGate,
+  normaliseMessage,
+  planAllowsGate,
+  planAllowsTier,
+  planFromVariantId,
+  planHasCapability,
+  planMeetsMin,
+  postPRComment,
+  recordExplainWhy,
+  recordExplainWhyFeedback,
+  recordVerdict,
+  registerTools,
+  scoreToConfidence,
+  setTelemetryEnabled,
+  slackRoutingRouter,
+  teamRouter,
+  toolCallCounts,
+  uploadCalibrationBatch
+};

package/dist/__stubs__/license.js

@@ -0,0 +1,35 @@
+import { PLANS } from "./plans.js";
+let _state = null;
+function getLicenseState() {
+  return _state;
+}
+function getActivePlanId() {
+  return _state?.planId ?? "free";
+}
+async function initLicense() {
+}
+async function activateKey(key) {
+  const planId = planFromVariantId(void 0);
+  _state = { key, planId, validatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  return { activated: true, planId };
+}
+async function deactivateKey() {
+  _state = null;
+}
+const VARIANT_PLAN_MAP = process.env.MERGEN_LS_VARIANT_MAP ? JSON.parse(process.env.MERGEN_LS_VARIANT_MAP) : {};
+function planFromVariantId(variantId) {
+  if (variantId == null || variantId === "" || variantId === 0) return "free";
+  const mapped = VARIANT_PLAN_MAP[String(variantId)];
+  return mapped && PLANS[mapped] ? mapped : "free";
+}
+async function revalidateLicense() {
+}
+export {
+  activateKey,
+  deactivateKey,
+  getActivePlanId,
+  getLicenseState,
+  initLicense,
+  planFromVariantId,
+  revalidateLicense
+};

package/dist/__stubs__/plans.js

@@ -0,0 +1,197 @@
+const NO_CAPS = {
+  hitlApproval: false,
+  overrideCorpusEnforce: false,
+  ciGate: false,
+  credentialBrokering: false,
+  agentIam: false
+};
+const CANONICAL_PLANS = {
+  free: {
+    id: "free",
+    name: "Free (OSS)",
+    rank: 0,
+    tagline: "Local-first logs and traces for developers",
+    seats: "1 developer",
+    maxServices: 1,
+    bufferSize: 2e3,
+    backendObservability: false,
+    analyzeCreditsPerMonth: 10,
+    overageCentsPerCredit: 0,
+    seatCap: 1,
+    overageCentsPerSeat: 0,
+    includedToolCallsPerMonth: 1e3,
+    overageCentsPerThousandToolCalls: 0,
+    capabilities: { ...NO_CAPS },
+    ctaUrl: "https://mergen.app/pricing",
+    priceDescription: "Free forever"
+  },
+  starter: {
+    id: "starter",
+    name: "Starter",
+    rank: 1,
+    tagline: "Shared policies, workspace collaboration, and safety for small AI teams",
+    seats: "5 included seats (+$15 / additional seat)",
+    maxServices: 5,
+    bufferSize: 1e4,
+    backendObservability: true,
+    analyzeCreditsPerMonth: 500,
+    overageCentsPerCredit: 10,
+    seatCap: 5,
+    overageCentsPerSeat: 1500,
+    includedToolCallsPerMonth: 1e4,
+    overageCentsPerThousandToolCalls: 500,
+    capabilities: { ...NO_CAPS, overrideCorpusEnforce: true, credentialBrokering: true },
+    ctaUrl: "https://mergen.app/pricing#starter",
+    priceDescription: "$79 / month founding price ($149 regular)"
+  },
+  team: {
+    id: "team",
+    name: "Team",
+    rank: 2,
+    tagline: "Slack approvals, RBAC, CI/CD gates, and runtime visualization for scaling companies",
+    seats: "20 included seats (+$20 / additional seat)",
+    maxServices: 25,
+    bufferSize: 5e4,
+    backendObservability: true,
+    analyzeCreditsPerMonth: 1e3,
+    overageCentsPerCredit: 5,
+    seatCap: 20,
+    overageCentsPerSeat: 2e3,
+    includedToolCallsPerMonth: 1e5,
+    overageCentsPerThousandToolCalls: 500,
+    capabilities: { hitlApproval: true, overrideCorpusEnforce: true, ciGate: true, credentialBrokering: true, agentIam: false },
+    ctaUrl: "https://mergen.app/pricing#team",
+    priceDescription: "$399 / month founding price ($499 regular)"
+  },
+  platform: {
+    id: "platform",
+    name: "Platform",
+    rank: 3,
+    tagline: "Unlimited scale on top of Team\u2019s governance primitives",
+    seats: "Unlimited",
+    maxServices: Infinity,
+    bufferSize: 2e5,
+    backendObservability: true,
+    analyzeCreditsPerMonth: 5e3,
+    overageCentsPerCredit: 2,
+    seatCap: Infinity,
+    overageCentsPerSeat: 0,
+    includedToolCallsPerMonth: 25e4,
+    overageCentsPerThousandToolCalls: 600,
+    capabilities: { hitlApproval: true, overrideCorpusEnforce: true, ciGate: true, credentialBrokering: true, agentIam: false },
+    ctaUrl: "https://mergen.app/pricing#platform",
+    priceDescription: "$10,000 / month base"
+  },
+  enterprise: {
+    id: "enterprise",
+    name: "Enterprise",
+    rank: 4,
+    tagline: "VPC deployment, SSO/IAM federation, and strict policy engine for regulated environments",
+    seats: "Custom",
+    maxServices: Infinity,
+    bufferSize: 1e6,
+    backendObservability: true,
+    analyzeCreditsPerMonth: 0,
+    overageCentsPerCredit: 0,
+    seatCap: Infinity,
+    overageCentsPerSeat: 0,
+    includedToolCallsPerMonth: 0,
+    overageCentsPerThousandToolCalls: 0,
+    capabilities: { hitlApproval: true, overrideCorpusEnforce: true, ciGate: true, credentialBrokering: true, agentIam: true },
+    ctaUrl: "https://mergen.app/pricing#enterprise",
+    priceDescription: "Custom ACV ($100K+ / year)"
+  }
+};
+const PLAN_ORDER = ["free", "starter", "team", "platform", "enterprise"];
+const LEGACY_ALIASES = {
+  solo_starter: "starter",
+  solo_pro: "team",
+  solo_power: "platform",
+  pay_as_you_go: "enterprise"
+};
+function buildPlans() {
+  const all = { ...CANONICAL_PLANS };
+  for (const [aliasId, canonicalId] of Object.entries(LEGACY_ALIASES)) {
+    const base = CANONICAL_PLANS[canonicalId];
+    all[aliasId] = { ...base, capabilities: { ...base.capabilities }, id: aliasId, name: `${base.name} (Legacy)` };
+  }
+  return all;
+}
+const PLANS = buildPlans();
+function getPlan(planId) {
+  return PLANS[planId ?? ""] ?? PLANS["free"];
+}
+function getPlanRank(planId) {
+  return getPlan(planId).rank;
+}
+function planMeetsMin(planId, minPlanId) {
+  return getPlanRank(planId) >= getPlanRank(minPlanId);
+}
+function planHasCapability(planId, cap) {
+  return getPlan(planId).capabilities[cap] === true;
+}
+const LOWEST_PAID_PLAN = "starter";
+function minPlanForGate(gate) {
+  if (gate === "free" || gate === "all") return "free";
+  if (gate === "pro") return LOWEST_PAID_PLAN;
+  return PLANS[gate] ? gate : "free";
+}
+function planAllowsGate(planId, gate) {
+  return planMeetsMin(planId, minPlanForGate(gate));
+}
+function planAllowsTier(planId, tier) {
+  return planAllowsGate(planId, tier);
+}
+function estimateToolCallOverageCents(planId, toolCallsThisMonth) {
+  const plan = getPlan(planId);
+  const included = plan.includedToolCallsPerMonth;
+  const rate = plan.overageCentsPerThousandToolCalls;
+  if (included === 0 || rate === 0) return 0;
+  const overage = Math.max(0, toolCallsThisMonth - included);
+  return Math.ceil(overage / 1e3 * rate);
+}
+function estimateSeatOverageCents(planId, activeSeats) {
+  const plan = getPlan(planId);
+  const cap = plan.seatCap;
+  const rate = plan.overageCentsPerSeat;
+  if (!isFinite(cap) || rate === 0) return 0;
+  return Math.max(0, activeSeats - cap) * rate;
+}
+const CAPABILITY_LABELS = {
+  hitlApproval: "HITL approve/deny holds",
+  overrideCorpusEnforce: "Override-corpus enforcement (BLOCK/HOLD)",
+  ciGate: "CI/CD blast-radius gate",
+  credentialBrokering: "Ephemeral multi-cloud credential brokering",
+  agentIam: "Agent IAM: SSO federation + enterprise credential governance"
+};
+const CAPABILITY_KEYS = Object.keys(CAPABILITY_LABELS);
+function describeEntitlement(planId) {
+  const plan = getPlan(planId);
+  const unlocked = CAPABILITY_KEYS.filter((cap) => plan.capabilities[cap]).map((cap) => CAPABILITY_LABELS[cap]);
+  const nextPlanId = PLAN_ORDER.find((id) => PLANS[id].rank === plan.rank + 1);
+  const upgradeLines = [];
+  if (nextPlanId) {
+    const next = getPlan(nextPlanId);
+    const newlyUnlocked = CAPABILITY_KEYS.filter((cap) => next.capabilities[cap] && !plan.capabilities[cap]).map((cap) => CAPABILITY_LABELS[cap]);
+    const suffix = newlyUnlocked.length > 0 ? ` \u2014 unlocks ${newlyUnlocked.join(", ")}` : "";
+    upgradeLines.push(
+      `> **Upgrade to ${next.name}** (${next.priceDescription})${suffix}`,
+      `> ${next.ctaUrl}`
+    );
+  }
+  return { unlocked, upgradeLines };
+}
+export {
+  PLANS,
+  PLAN_ORDER,
+  describeEntitlement,
+  estimateSeatOverageCents,
+  estimateToolCallOverageCents,
+  getPlan,
+  getPlanRank,
+  minPlanForGate,
+  planAllowsGate,
+  planAllowsTier,
+  planHasCapability,
+  planMeetsMin
+};