@keepgoingdev/mcp-server 0.7.0 → 0.7.1

package/dist/index.js

@@ -1214,7 +1214,14 @@ function getLicenseForFeature(feature) {
     return features?.includes(feature);
   });
 }
+function getAllLicensesNeedingRevalidation() {
+  return getActiveLicenses().filter((l) => needsRevalidation(l));
+}
 var REVALIDATION_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
+function needsRevalidation(entry) {
+  const lastValidated = new Date(entry.lastValidatedAt).getTime();
+  return Date.now() - lastValidated > REVALIDATION_THRESHOLD_MS;
+}
 
 // ../../packages/shared/src/featureGate.ts
 var DefaultFeatureGate = class {
@@ -2096,6 +2103,39 @@ async function activateLicense(licenseKey, instanceName, options) {
     return { valid: false, error: message };
   }
 }
+async function validateLicense(licenseKey, instanceId, options) {
+  try {
+    const res = await fetchWithTimeout(`${BASE_URL}/validate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({ license_key: licenseKey, instance_id: instanceId })
+    });
+    const data = await safeJson(res);
+    if (!res.ok || !data?.valid) {
+      return { valid: false, isNetworkError: false, error: data?.error || `Validation failed (${res.status})` };
+    }
+    if (!options?.allowTestMode && data.license_key?.test_mode) {
+      return { valid: false, isNetworkError: false, error: "This is a test license key. Please use a production license key from your purchase confirmation." };
+    }
+    if (!options?.allowTestMode) {
+      const productError = validateProductIdentity(data.meta);
+      if (productError) {
+        return { valid: false, isNetworkError: false, error: productError };
+      }
+    }
+    return {
+      valid: true,
+      licenseKey: data.license_key?.key,
+      customerName: data.meta?.customer_name,
+      productName: data.meta?.product_name,
+      variantId: data.meta?.variant_id,
+      variantName: data.meta?.variant_name
+    };
+  } catch (err) {
+    const message = err instanceof Error && err.name === "AbortError" ? "Request timed out. Please check your network connection and try again." : err instanceof Error ? err.message : "Network error";
+    return { valid: false, isNetworkError: true, error: message };
+  }
+}
 async function deactivateLicense(licenseKey, instanceId) {
   try {
     const res = await fetchWithTimeout(`${BASE_URL}/deactivate`, {
@@ -2114,6 +2154,52 @@ async function deactivateLicense(licenseKey, instanceId) {
   }
 }
 
+// ../../packages/shared/src/licenseRevalidation.ts
+async function revalidateStaleLicenses(options) {
+  const stale = getAllLicensesNeedingRevalidation();
+  const result = { checked: stale.length, refreshed: 0, revoked: 0, skippedNetworkError: 0 };
+  if (stale.length === 0) return result;
+  const updates = /* @__PURE__ */ new Map();
+  for (const entry of stale) {
+    const vResult = await validateLicense(entry.licenseKey, entry.instanceId, {
+      allowTestMode: options?.allowTestMode
+    });
+    if (vResult.valid) {
+      const patch = {
+        lastValidatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (vResult.customerName) patch.customerName = vResult.customerName;
+      updates.set(entry.licenseKey, patch);
+      result.refreshed++;
+    } else if (vResult.isNetworkError) {
+      result.skippedNetworkError++;
+    } else {
+      updates.set(entry.licenseKey, { status: "inactive" });
+      result.revoked++;
+    }
+  }
+  if (updates.size > 0) {
+    const store = readLicenseStore();
+    for (const [key, patch] of updates) {
+      const idx = store.licenses.findIndex((l) => l.licenseKey === key);
+      if (idx >= 0) {
+        Object.assign(store.licenses[idx], patch);
+      }
+    }
+    writeLicenseStore(store);
+  }
+  return result;
+}
+async function getLicenseForFeatureWithRevalidation(feature, options) {
+  const license = getLicenseForFeature(feature);
+  if (!license) return void 0;
+  if (needsRevalidation(license)) {
+    await revalidateStaleLicenses(options);
+    return getLicenseForFeature(feature);
+  }
+  return license;
+}
+
 // src/tools/getMomentum.ts
 import { z } from "zod";
 function registerGetMomentum(server, reader, workspacePath) {
@@ -2450,7 +2536,7 @@ function registerGetDecisions(server, reader) {
           ]
         };
       }
-      if (process.env.KEEPGOING_PRO_BYPASS !== "1" && !getLicenseForFeature("decisions")) {
+      if (process.env.KEEPGOING_PRO_BYPASS !== "1" && !await getLicenseForFeatureWithRevalidation("decisions")) {
         return {
           content: [
             {
@@ -2516,7 +2602,7 @@ function registerGetCurrentTask(server, reader) {
           ]
         };
       }
-      if (process.env.KEEPGOING_PRO_BYPASS !== "1" && !getLicenseForFeature("session-awareness")) {
+      if (process.env.KEEPGOING_PRO_BYPASS !== "1" && !await getLicenseForFeatureWithRevalidation("session-awareness")) {
         return {
           content: [
             {
@@ -2991,7 +3077,7 @@ async function handlePrintMomentum() {
   process.exit(0);
 }
 async function handlePrintCurrent() {
-  if (process.env.KEEPGOING_PRO_BYPASS !== "1" && !getLicenseForFeature("session-awareness")) {
+  if (process.env.KEEPGOING_PRO_BYPASS !== "1" && !await getLicenseForFeatureWithRevalidation("session-awareness")) {
     process.exit(0);
   }
   const wsPath = resolveWsPath();
@@ -3079,7 +3165,7 @@ async function handleSaveCheckpoint() {
     branch: gitBranch ?? void 0,
     updatedAt: checkpoint.timestamp
   });
-  if (process.env.KEEPGOING_PRO_BYPASS === "1" || getLicenseForFeature("decisions")) {
+  if (process.env.KEEPGOING_PRO_BYPASS === "1" || await getLicenseForFeatureWithRevalidation("decisions")) {
     for (let i = 0; i < commitHashes.length; i++) {
       const hash = commitHashes[i];
       const message = commitMessages[i];
@@ -3379,7 +3465,7 @@ async function handleContinueOn() {
 // src/cli/detectDecisions.ts
 async function handleDetectDecisions() {
   const wsPath = resolveWsPath();
-  if (!(process.env.KEEPGOING_PRO_BYPASS === "1" || getLicenseForFeature("decisions"))) {
+  if (!(process.env.KEEPGOING_PRO_BYPASS === "1" || await getLicenseForFeatureWithRevalidation("decisions"))) {
     process.exit(0);
   }
   const reader = new KeepGoingReader(wsPath);