seo-intel 1.1.7 → 1.1.9

package/lib/license.js

@@ -1,22 +1,25 @@
 /**
  * SEO Intel — License System
  *
- * Validation priority:
- *   1. FROGGO_TOKEN → validate against Froggo API
- *   2. SEO_INTEL_LICENSE → validate against Lemon Squeezy API
- *   3. No key → Free tier
+ * Validation flow:
+ *   1. SEO_INTEL_LICENSE → activate/validate against Lemon Squeezy License API
+ *   2. No key → Free tier
  *
  * Local cache: ~/.seo-intel/license-cache.json
  *   - LS keys: cache 24h, stale up to 7 days if API unreachable
- *   - Froggo tokens: cache 24h, stale up to 24h if API unreachable
  *   - Beyond stale limit → degrade to free tier + warn
  *
+ * Activation flow (Lemon Squeezy):
+ *   - First run: POST /v1/licenses/activate → stores instance_id locally
+ *   - Subsequent runs: POST /v1/licenses/validate with instance_id
+ *   - Machine-specific: instance_name = "seo-intel-<machineId>"
+ *
  * Free tier: crawl + raw HTML export only. No AI extraction or analysis.
- * Solo (€19.99/mo or €199/yr via LS, $9.99/mo via Froggo): Full AI extraction + analysis, all commands.
+ * Solo (€19.99/mo or €199.99/yr): Full AI extraction + analysis, all commands.
  * Agency: Later phase — not sold yet.
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { chmodSync, existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { hostname, userInfo, platform } from 'os';
@@ -32,8 +35,6 @@ const CACHE_PATH = join(CACHE_DIR, 'license-cache.json');
 // Stale limits (ms)
 const LS_CACHE_TTL = 24 * 60 * 60 * 1000;        // 24h fresh
 const LS_STALE_LIMIT = 7 * 24 * 60 * 60 * 1000;   // 7 days stale max
-const FROGGO_CACHE_TTL = 24 * 60 * 60 * 1000;      // 24h fresh
-const FROGGO_STALE_LIMIT = 24 * 60 * 60 * 1000;    // 24h stale max
 
 // ── Tiers ──────────────────────────────────────────────────────────────────
 
@@ -91,9 +92,18 @@ function writeCache(data) {
   try {
     mkdirSync(CACHE_DIR, { recursive: true });
     writeFileSync(CACHE_PATH, JSON.stringify(data, null, 2), 'utf8');
+    try { chmodSync(CACHE_PATH, 0o600); } catch {}
   } catch { /* best-effort */ }
 }
 
+function getTierFromVariantName(variantName) {
+  const normalized = (variantName || '').toLowerCase();
+  if (!normalized.includes('agency') && !normalized.includes('solo') && !normalized.includes('pro')) {
+    console.warn(`[license] Unknown variant name: "${normalized}" — defaulting to solo`);
+  }
+  return normalized.includes('agency') ? 'agency' : 'solo';
+}
+
 /**
  * Check if cached validation is still usable.
  * Returns { valid, tier, stale } or null if cache is expired/missing.
@@ -103,123 +113,176 @@ function checkCache(key) {
   if (!cache || cache.key !== key) return null;
 
   const age = Date.now() - (cache.validatedAt || 0);
-  const ttl = cache.source === 'froggo' ? FROGGO_CACHE_TTL : LS_CACHE_TTL;
-  const staleLimit = cache.source === 'froggo' ? FROGGO_STALE_LIMIT : LS_STALE_LIMIT;
 
-  if (age < ttl) {
-    return { valid: true, tier: cache.tier, stale: false, source: cache.source };
+  if (age < LS_CACHE_TTL) {
+    return { valid: true, tier: cache.tier, stale: false, source: 'lemon-squeezy', instanceId: cache.instanceId };
   }
-  if (age < staleLimit) {
-    return { valid: true, tier: cache.tier, stale: true, source: cache.source };
+  if (age < LS_STALE_LIMIT) {
+    return { valid: true, tier: cache.tier, stale: true, source: 'lemon-squeezy', instanceId: cache.instanceId };
   }
   return null; // Expired beyond stale limit
 }
 
-// ── Lemon Squeezy Validation ───────────────────────────────────────────────
+// ── Lemon Squeezy License API ────────────────────────────────────────────
 
 /**
- * Validate a license key against Lemon Squeezy API.
- * Returns { valid, tier, error? } — never throws.
+ * Activate a license key against Lemon Squeezy.
+ * POST https://api.lemonsqueezy.com/v1/licenses/activate
+ * Params: license_key, instance_name
+ * Returns instance_id on success.
  */
-async function validateWithLS(key) {
+async function activateWithLS(key) {
   try {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), 8000);
 
-    const res = await fetch('https://api.lemonsqueezy.com/v1/licenses/validate', {
+    const body = new URLSearchParams({
+      license_key: key,
+      instance_name: `seo-intel-${getMachineId()}`,
+    });
+
+    const res = await fetch('https://api.lemonsqueezy.com/v1/licenses/activate', {
       signal: controller.signal,
       method: 'POST',
-      headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
-      body: JSON.stringify({
-        license_key: key,
-        instance_name: `seo-intel-${getMachineId()}`,
-      }),
+      headers: { 'Accept': 'application/json' },
+      body,
     });
 
     clearTimeout(timeout);
     const data = await res.json();
 
-    if (data.valid) {
-      // Determine tier from LS metadata
-      // Convention: product variant name contains "solo" or "agency"
-      const variantName = (data.meta?.variant_name || data.license_key?.key_data?.variant || '').toLowerCase();
-      const tier = variantName.includes('agency') ? 'agency' : 'solo';
-      return { valid: true, tier };
+    if (data.activated) {
+      const variantName = (data.meta?.variant_name || '').toLowerCase();
+      const tier = getTierFromVariantName(variantName);
+      return {
+        valid: true,
+        tier,
+        instanceId: data.instance?.id || null,
+        meta: data.meta,
+      };
+    }
+
+    // Already at activation limit? Try validate instead (might be same machine re-activating)
+    if (data.error && data.error.includes('activation limit')) {
+      return { valid: false, error: data.error, activationLimitReached: true };
     }
 
-    return { valid: false, error: data.error || 'License key not valid' };
+    return { valid: false, error: data.error || 'Activation failed' };
   } catch (err) {
     return { valid: false, error: `Network error: ${err.message}`, offline: true };
   }
 }
 
-// ── Froggo Token Validation ────────────────────────────────────────────────
-
 /**
- * Validate a Froggo marketplace token.
- * Returns { valid, tier, error? } — never throws.
+ * Validate a license key against Lemon Squeezy.
+ * POST https://api.lemonsqueezy.com/v1/licenses/validate
+ * Params: license_key, instance_id (optional)
  */
-async function validateWithFroggo(token) {
+async function validateWithLS(key, instanceId) {
   try {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), 8000);
 
-    const res = await fetch('https://api.froggo.pro/v1/licenses/validate', {
+    const params = { license_key: key };
+    if (instanceId) params.instance_id = instanceId;
+    const body = new URLSearchParams(params);
+
+    const res = await fetch('https://api.lemonsqueezy.com/v1/licenses/validate', {
       signal: controller.signal,
       method: 'POST',
-      headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
-      body: JSON.stringify({
-        token,
-        product: 'seo-intel',
-      }),
+      headers: { 'Accept': 'application/json' },
+      body,
     });
 
     clearTimeout(timeout);
     const data = await res.json();
 
     if (data.valid) {
-      const tier = (data.tier || 'solo').toLowerCase();
-      return { valid: true, tier: tier === 'agency' ? 'agency' : 'solo' };
+      const variantName = (data.meta?.variant_name || '').toLowerCase();
+      const tier = getTierFromVariantName(variantName);
+      return {
+        valid: true,
+        tier,
+        instanceId: data.instance?.id || instanceId,
+        status: data.license_key?.status,
+        meta: data.meta,
+      };
     }
 
-    return { valid: false, error: data.error || 'Token not valid' };
+    return { valid: false, error: data.error || 'License key not valid', status: data.license_key?.status };
   } catch (err) {
     return { valid: false, error: `Network error: ${err.message}`, offline: true };
   }
 }
 
+/**
+ * Deactivate a license key instance.
+ * POST https://api.lemonsqueezy.com/v1/licenses/deactivate
+ * Params: license_key, instance_id
+ */
+export async function deactivateLicense() {
+  const keyInfo = readKeyFromEnv();
+  if (!keyInfo) return { deactivated: false, error: 'No license key found' };
+
+  const cache = readCache();
+  const instanceId = cache?.instanceId;
+  if (!instanceId) return { deactivated: false, error: 'No active instance to deactivate' };
+
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 8000);
+
+    const body = new URLSearchParams({
+      license_key: keyInfo.value,
+      instance_id: instanceId,
+    });
+
+    const res = await fetch('https://api.lemonsqueezy.com/v1/licenses/deactivate', {
+      signal: controller.signal,
+      method: 'POST',
+      headers: { 'Accept': 'application/json' },
+      body,
+    });
+
+    clearTimeout(timeout);
+    const data = await res.json();
+
+    if (data.deactivated) {
+      // Clear local cache
+      writeCache({});
+      _cachedLicense = undefined;
+      return { deactivated: true };
+    }
+
+    return { deactivated: false, error: data.error || 'Deactivation failed' };
+  } catch (err) {
+    return { deactivated: false, error: `Network error: ${err.message}` };
+  }
+}
+
 // ── License Loading ─────────────────────────────────────────────────────────
 
 let _cachedLicense = undefined;
 
 /**
- * Read the license key / token from environment or .env file.
+ * Read the license key from environment or .env file.
  * Returns { type, value } or null.
  */
 function readKeyFromEnv() {
-  // 1. Check Froggo token first (marketplace priority)
-  let froggoToken = process.env.FROGGO_TOKEN;
   let lsKey = process.env.SEO_INTEL_LICENSE;
 
-  // 2. Check .env file
-  if (!froggoToken || !lsKey) {
+  // Check .env file
+  if (!lsKey) {
     const envPath = join(ROOT, '.env');
     if (existsSync(envPath)) {
       try {
         const content = readFileSync(envPath, 'utf8');
-        if (!froggoToken) {
-          const match = content.match(/^FROGGO_TOKEN=(.+)$/m);
-          if (match) froggoToken = match[1].trim().replace(/^["']|["']$/g, '');
-        }
-        if (!lsKey) {
-          const match = content.match(/^SEO_INTEL_LICENSE=(.+)$/m);
-          if (match) lsKey = match[1].trim().replace(/^["']|["']$/g, '');
-        }
+        const match = content.match(/^SEO_INTEL_LICENSE=(.+)$/m);
+        if (match) lsKey = match[1].trim().replace(/^["']|["']$/g, '');
       } catch { /* ok */ }
     }
   }
 
-  if (froggoToken) return { type: 'froggo', value: froggoToken };
   if (lsKey) return { type: 'lemon-squeezy', value: lsKey };
   return null;
 }
@@ -260,7 +323,13 @@ export function loadLicense() {
 }
 
 /**
- * Async license activation — validates against remote API and caches result.
+ * Async license activation — validates against Lemon Squeezy and caches result.
+ *
+ * Flow:
+ *   1. If we have a cached instanceId → validate with it
+ *   2. If no instanceId → activate (creates new instance)
+ *   3. If activation limit reached → validate without instanceId (key-level check)
+ *
  * Call this at startup or when loadLicense() returns needsActivation: true.
  * Returns the validated license object.
  */
@@ -273,34 +342,46 @@ export async function activateLicense() {
     return _cachedLicense;
   }
 
+  // Check if we already have an instanceId from a previous activation
+  const cache = readCache();
+  const existingInstanceId = (cache && cache.key === keyInfo.value) ? cache.instanceId : null;
+
   let result;
-  if (keyInfo.type === 'froggo') {
-    result = await validateWithFroggo(keyInfo.value);
+
+  if (existingInstanceId) {
+    // We have a stored instance — validate it
+    result = await validateWithLS(keyInfo.value, existingInstanceId);
   } else {
-    result = await validateWithLS(keyInfo.value);
+    // No stored instance — try to activate
+    result = await activateWithLS(keyInfo.value);
+
+    // If activation limit reached, fall back to key-level validate
+    if (!result.valid && result.activationLimitReached) {
+      result = await validateWithLS(keyInfo.value);
+    }
   }
 
   if (result.valid) {
-    // Cache the successful validation
+    // Cache the successful validation with instanceId
     writeCache({
       key: keyInfo.value,
       tier: result.tier,
       validatedAt: Date.now(),
-      source: keyInfo.type,
+      source: 'lemon-squeezy',
+      instanceId: result.instanceId || existingInstanceId,
       machineId: getMachineId(),
     });
 
     const tierData = TIERS[result.tier] || TIERS.solo;
-    _cachedLicense = { active: true, tier: result.tier, key: keyInfo.value, source: keyInfo.type, ...tierData };
+    _cachedLicense = { active: true, tier: result.tier, key: keyInfo.value, source: 'lemon-squeezy', ...tierData };
     return _cachedLicense;
   }
 
   if (result.offline) {
     // Network error — check if we have any stale cache at all
-    const cache = readCache();
     if (cache && cache.key === keyInfo.value) {
       const tierData = TIERS[cache.tier] || TIERS.solo;
-      _cachedLicense = { active: true, tier: cache.tier, key: keyInfo.value, source: cache.source, stale: true, ...tierData };
+      _cachedLicense = { active: true, tier: cache.tier, key: keyInfo.value, source: 'lemon-squeezy', stale: true, ...tierData };
       return _cachedLicense;
     }
   }

package/lib/updater.js

@@ -6,7 +6,7 @@
  *
  * Two update channels:
  *   - npm registry (public installs via `npm install -g seo-intel`)
- *   - froggo.pro   (direct downloads / pro users)
+ *   - ukkometa.fi  (direct downloads / pro users)
  *
  * Usage:
  *   import { checkForUpdates, printUpdateNotice } from './updater.js';
@@ -17,6 +17,7 @@
  */
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 
@@ -40,8 +41,8 @@ export function getCurrentVersion() {
 
 // ── Cache file ─────────────────────────────────────────────────────────────
 
-const CACHE_DIR = join(ROOT, '.cache');
-const CACHE_FILE = join(CACHE_DIR, 'update-check.json');
+const CACHE_DIR = join(homedir(), '.seo-intel');
+const CACHE_FILE = join(CACHE_DIR, 'update-cache.json');
 const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
 
 function readCache() {
@@ -113,15 +114,15 @@ async function checkNpm() {
 }
 
 /**
- * Check froggo.pro for latest version.
+ * Check ukkometa.fi for latest version.
  * Endpoint returns { version, changelog?, downloadUrl? }
  */
-async function checkFroggo() {
+async function checkUkkometa() {
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), 5000);
 
   try {
-    const res = await fetch('https://froggo.pro/api/seo-intel/version', {
+    const res = await fetch('https://ukkometa.fi/api/seo-intel/version', {
       signal: controller.signal,
       headers: { 'Accept': 'application/json' },
     });
@@ -165,12 +166,12 @@ export function checkForUpdates() {
       const current = getCurrentVersion();
 
       // Check both sources in parallel
-      const [npmVersion, froggoData] = await Promise.all([
+      const [npmVersion, ukkometaData] = await Promise.all([
         checkNpm(),
-        checkFroggo(),
+        checkUkkometa(),
       ]);
 
-      const froggoVersion = froggoData?.version || null;
+      const ukkometaVersion = ukkometaData?.version || null;
 
       // Determine the highest available version
       let latestVersion = current;
@@ -182,11 +183,11 @@ export function checkForUpdates() {
         latestVersion = npmVersion;
         source = 'npm';
       }
-      if (froggoVersion && compareSemver(froggoVersion, latestVersion) > 0) {
-        latestVersion = froggoVersion;
-        source = 'froggo';
-        changelog = froggoData.changelog;
-        downloadUrl = froggoData.downloadUrl;
+      if (ukkometaVersion && compareSemver(ukkometaVersion, latestVersion) > 0) {
+        latestVersion = ukkometaVersion;
+        source = 'ukkometa';
+        changelog = ukkometaData.changelog;
+        downloadUrl = ukkometaData.downloadUrl;
       }
 
       const hasUpdate = compareSemver(latestVersion, current) > 0;
@@ -199,10 +200,10 @@ export function checkForUpdates() {
         changelog,
         downloadUrl,
         npmVersion,
-        froggoVersion,
-        security: froggoData?.security || false,
-        securitySeverity: froggoData?.securitySeverity || null,
-        updatePolicy: froggoData?.updatePolicy || null,
+        ukkometaVersion,
+        security: ukkometaData?.security || false,
+        securitySeverity: ukkometaData?.securitySeverity || null,
+        updatePolicy: ukkometaData?.updatePolicy || null,
       };
 
       writeCache(_updateResult);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "seo-intel",
-  "version": "1.1.7",
+  "version": "1.1.9",
   "description": "Local Ahrefs-style SEO competitor intelligence. Crawl → SQLite → cloud analysis.",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",
@@ -56,7 +56,8 @@
     "Start SEO Intel.command",
     "Setup SEO Intel.command",
     "Start SEO Intel.bat",
-    "start-seo-intel.sh"
+    "start-seo-intel.sh",
+    "CHANGELOG.md"
   ],
   "scripts": {
     "crawl": "node cli.js crawl",

package/seo-audit.js

@@ -507,7 +507,7 @@ async function generateReport(rawUrl) {
 
   lines.push(`# SEO Audit Report — ${rawUrl}`);
   lines.push(`**Date:** ${date}  `);
-  lines.push(`**Tool:** SEO Intel (froggo.pro)\n`);
+  lines.push(`**Tool:** SEO Intel (ukkometa.fi)\n`);
   lines.push(`---\n`);
 
   // Score card
@@ -596,7 +596,7 @@ async function generateReport(rawUrl) {
   }
   lines.push('');
   lines.push(`---\n`);
-  lines.push(`*Generated by SEO Intel — froggo.pro*`);
+  lines.push(`*Generated by SEO Intel — ukkometa.fi*`);
 
   const md = lines.join('\n');
   writeFileSync(outFile, md);

package/server.js

@@ -501,13 +501,11 @@ async function handleRequest(req, res) {
         envContent = readFileSync(envPath, 'utf8');
       }
 
-      // Determine key type
-      const isFroggo = key.startsWith('FROGGO_') || key.length > 60;
-      const envVar = isFroggo ? 'FROGGO_TOKEN' : 'SEO_INTEL_LICENSE';
+      const envVar = 'SEO_INTEL_LICENSE';
 
-      // Remove existing lines for both key types
+      // Remove existing license line
       const lines = envContent.split('\n').filter(l =>
-        !l.startsWith('SEO_INTEL_LICENSE=') && !l.startsWith('FROGGO_TOKEN=')
+        !l.startsWith('SEO_INTEL_LICENSE=')
       );
       lines.push(`${envVar}=${key}`);