@ggboi360/mobile-dev-mcp 0.1.0 → 0.3.0

package/dist/license.js

@@ -1,606 +1,297 @@
-/**
- * License validation module for Mobile Dev MCP
- *
- * Tiers:
- * - TRIAL: No license, 50 tool requests then blocked
- * - BASIC ($6/mo): 17 core tools (Android + iOS basics), 50 line limits, 1 device
- * - ADVANCED ($8/wk, $12/mo, $99/yr): All 41 tools, unlimited, multi-device
- *
- * Handles:
- * - License key validation against API
- * - Local caching of license status
- * - Trial usage tracking
- * - Graceful degradation when offline
- * - Feature gating based on tier
- */
+// Mobile Dev MCP - License Management
+// Read-only debugging tool - simplified 2-tier system
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
+import * as https from "https";
 import * as crypto from "crypto";
-// ============================================================================
-// CONSTANTS
-// ============================================================================
-const CONFIG_DIR = path.join(os.homedir(), ".mobiledev-mcp");
-const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+import { execSync } from "child_process";
+import { TIER_LIMITS, FREE_TOOLS, ADVANCED_TOOLS } from "./types.js";
+// Re-export for tests
+export { TIER_LIMITS, FREE_TOOLS, ADVANCED_TOOLS };
+const CONFIG_DIR = path.join(os.homedir(), ".mobile-dev-mcp");
 const LICENSE_CACHE_FILE = path.join(CONFIG_DIR, "license.json");
-const TRIAL_FILE = path.join(CONFIG_DIR, "trial.json");
-// How long to trust cached license without revalidation
-const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
-// Grace period if API is down but we have a cached valid license
-const GRACE_PERIOD_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
-// Default API endpoint - UPDATE THIS after deploying your Cloudflare Worker!
-const DEFAULT_API_ENDPOINT = "https://mobiledev-license-api.giladworkersdev.workers.dev";
-// Trial settings
-const TRIAL_LIMIT = 50; // Number of tool requests allowed in trial
-// ============================================================================
-// FEATURE TIERS
+// License validation API (Cloudflare Worker)
+const LICENSE_API_URL = "https://mobiledev-license-api.giladworkersdev.workers.dev/validate";
+// Cache TTL: 1 hour (reduced from 24 hours for faster revocation)
+const CACHE_TTL_MS = 60 * 60 * 1000;
 // ============================================================================
-// BASIC TIER ($6/mo) - Core tools, available to all paid users
-export const BASIC_TOOLS = [
-    // Android tools
-    "get_metro_logs",
-    "get_adb_logs",
-    "screenshot_emulator",
-    "list_devices",
-    "check_metro_status",
-    "get_app_info",
-    "clear_app_data",
-    "restart_adb",
-    "get_device_info",
-    "start_metro_logging",
-    "stop_metro_logging",
-    // iOS Simulator tools
-    "list_ios_simulators",
-    "screenshot_ios_simulator",
-    "get_ios_simulator_logs",
-    "get_ios_simulator_info",
-    // License tools
-    "get_license_status",
-    "set_license_key",
-];
-// ADVANCED TIER ($8/wk, $12/mo, $99/yr) - Pro tools, only for Advanced subscribers
-export const ADVANCED_TOOLS = [
-    // Android streaming & monitoring
-    "stream_adb_realtime",
-    "stop_adb_streaming",
-    "screenshot_history",
-    "watch_for_errors",
-    "multi_device_logs",
-    // Android interaction tools
-    "tap_screen",
-    "input_text",
-    "press_button",
-    "swipe_screen",
-    "launch_app",
-    "install_apk",
-    // iOS Simulator advanced tools
-    "boot_ios_simulator",
-    "shutdown_ios_simulator",
-    "install_ios_app",
-    "launch_ios_app",
-    "terminate_ios_app",
-    "ios_open_url",
-    "ios_push_notification",
-    "ios_set_location",
-    // React DevTools integration
-    "setup_react_devtools",
-    "check_devtools_connection",
-    "get_react_component_tree",
-    "inspect_react_component",
-    "search_react_components",
-];
-// Limits for each tier
-export const TIER_LIMITS = {
-    trial: {
-        maxLogLines: 50, // Same as Basic during trial
-        maxDevices: 1,
-        screenshotHistory: 0,
-    },
-    basic: {
-        maxLogLines: 50,
-        maxDevices: 1,
-        screenshotHistory: 0,
-    },
-    advanced: {
-        maxLogLines: Infinity,
-        maxDevices: 3,
-        screenshotHistory: 20,
-    },
-};
+// MACHINE ID
 // ============================================================================
-// CONFIG MANAGEMENT
-// ============================================================================
-function ensureConfigDir() {
-    if (!fs.existsSync(CONFIG_DIR)) {
-        fs.mkdirSync(CONFIG_DIR, { recursive: true });
-    }
-}
-export function loadConfig() {
-    ensureConfigDir();
-    const defaultConfig = {
-        metroPort: 8081,
-        logBufferSize: 100,
-        apiEndpoint: DEFAULT_API_ENDPOINT,
-    };
-    if (!fs.existsSync(CONFIG_FILE)) {
-        saveConfig(defaultConfig);
-        return defaultConfig;
-    }
+let cachedMachineId = null;
+function getMachineId() {
+    if (cachedMachineId)
+        return cachedMachineId;
     try {
-        const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
-        const loaded = JSON.parse(raw);
-        return { ...defaultConfig, ...loaded };
+        if (process.platform === "win32") {
+            const output = execSync("wmic csproduct get uuid", { encoding: "utf-8" });
+            const lines = output.trim().split("\n");
+            if (lines.length > 1) {
+                cachedMachineId = lines[1].trim();
+                return cachedMachineId;
+            }
+        }
+        else if (process.platform === "linux") {
+            if (fs.existsSync("/etc/machine-id")) {
+                cachedMachineId = fs.readFileSync("/etc/machine-id", "utf-8").trim();
+                return cachedMachineId;
+            }
+        }
+        else if (process.platform === "darwin") {
+            const output = execSync("ioreg -rd1 -c IOPlatformExpertDevice | grep IOPlatformUUID", { encoding: "utf-8" });
+            const match = output.match(/"([A-F0-9-]+)"/);
+            if (match) {
+                cachedMachineId = match[1];
+                return cachedMachineId;
+            }
+        }
     }
     catch {
-        return defaultConfig;
+        // Ignore errors
     }
-}
-export function saveConfig(config) {
-    ensureConfigDir();
-    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
-}
-export function setLicenseKey(key) {
-    const config = loadConfig();
-    config.licenseKey = key;
-    saveConfig(config);
-    // Clear cached license to force revalidation
-    clearLicenseCache();
+    cachedMachineId = os.hostname();
+    return cachedMachineId;
 }
 // ============================================================================
-// MACHINE ID (for license binding)
+// CACHE INTEGRITY (HMAC signing)
 // ============================================================================
-function getMachineId() {
-    const info = [
-        os.hostname(),
-        os.platform(),
-        os.arch(),
-        os.cpus()[0]?.model || "unknown",
-    ].join("|");
-    return crypto.createHash("sha256").update(info).digest("hex").substring(0, 32);
+function getCacheSecret() {
+    // Use machine ID as part of secret to prevent cache file copying between machines
+    return `mobiledev-${getMachineId()}-cache-v1`;
 }
-// ============================================================================
-// LICENSE CACHE
-// ============================================================================
-function loadLicenseCache() {
-    if (!fs.existsSync(LICENSE_CACHE_FILE)) {
-        return null;
-    }
+function signCacheData(data) {
+    const payload = JSON.stringify(data);
+    return crypto.createHmac("sha256", getCacheSecret()).update(payload).digest("hex");
+}
+function verifyCacheSignature(data, signature) {
+    const expected = signCacheData(data);
+    const sigBuffer = Buffer.from(signature);
+    const expBuffer = Buffer.from(expected);
+    // Length check before timingSafeEqual to prevent length-based timing leaks
+    // (timingSafeEqual throws if lengths differ, which is itself a timing leak)
+    if (sigBuffer.length !== expBuffer.length)
+        return false;
+    return crypto.timingSafeEqual(sigBuffer, expBuffer);
+}
+function loadCachedLicense() {
     try {
-        const raw = fs.readFileSync(LICENSE_CACHE_FILE, "utf-8");
-        return JSON.parse(raw);
+        if (fs.existsSync(LICENSE_CACHE_FILE)) {
+            const raw = JSON.parse(fs.readFileSync(LICENSE_CACHE_FILE, "utf-8"));
+            // Verify signature to prevent tampering
+            if (raw.data && raw.signature) {
+                if (verifyCacheSignature(raw.data, raw.signature)) {
+                    return raw.data;
+                }
+                else {
+                    // Signature mismatch - delete corrupted cache
+                    console.error("License cache signature mismatch - clearing cache");
+                    fs.unlinkSync(LICENSE_CACHE_FILE);
+                    return null;
+                }
+            }
+            // Legacy cache without signature - delete it
+            fs.unlinkSync(LICENSE_CACHE_FILE);
+        }
     }
     catch {
-        return null;
+        // Ignore errors
     }
+    return null;
 }
-function saveLicenseCache(license) {
-    ensureConfigDir();
-    fs.writeFileSync(LICENSE_CACHE_FILE, JSON.stringify(license, null, 2));
-}
-function clearLicenseCache() {
-    if (fs.existsSync(LICENSE_CACHE_FILE)) {
-        fs.unlinkSync(LICENSE_CACHE_FILE);
+function saveLicenseCache(data) {
+    try {
+        if (!fs.existsSync(CONFIG_DIR)) {
+            fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+        }
+        const signature = signCacheData(data);
+        const cache = { data, signature };
+        // Write with restricted permissions (owner read/write only)
+        fs.writeFileSync(LICENSE_CACHE_FILE, JSON.stringify(cache, null, 2), { mode: 0o600 });
+    }
+    catch {
+        // Ignore write errors
     }
-}
-function isCacheFresh(license) {
-    const validatedAt = new Date(license.validatedAt).getTime();
-    const now = Date.now();
-    return now - validatedAt < CACHE_TTL_MS;
-}
-function isWithinGracePeriod(license) {
-    const validatedAt = new Date(license.validatedAt).getTime();
-    const now = Date.now();
-    return now - validatedAt < GRACE_PERIOD_MS;
 }
 // ============================================================================
-// TRIAL TRACKING
+// LICENSE VALIDATION
 // ============================================================================
-function loadTrialInfo() {
-    if (!fs.existsSync(TRIAL_FILE)) {
-        return null;
-    }
+export async function checkLicense() {
     try {
-        const raw = fs.readFileSync(TRIAL_FILE, "utf-8");
-        return JSON.parse(raw);
+        const cached = loadCachedLicense();
+        if (cached && cached.licenseKey) {
+            const now = Date.now();
+            const lastCheck = cached.lastValidated || 0;
+            // Check if cache is still valid (1 hour TTL)
+            if (now - lastCheck < CACHE_TTL_MS) {
+                return {
+                    tier: cached.tier,
+                    valid: true,
+                    licenseKey: cached.licenseKey,
+                    expiresAt: cached.expiresAt,
+                };
+            }
+            // Re-validate with API
+            const validated = await validateWithLemonSqueezy(cached.licenseKey);
+            if (validated) {
+                return validated;
+            }
+            // Validation failed - clear cache and fall back to free
+            try {
+                fs.unlinkSync(LICENSE_CACHE_FILE);
+            }
+            catch {
+                // Ignore
+            }
+        }
+        return { tier: "free", valid: true };
     }
     catch {
-        return null;
-    }
-}
-function saveTrialInfo(trial) {
-    ensureConfigDir();
-    fs.writeFileSync(TRIAL_FILE, JSON.stringify(trial, null, 2));
-}
-function getMachineIdForTrial() {
-    const info = [
-        os.hostname(),
-        os.platform(),
-        os.arch(),
-        os.cpus()[0]?.model || "unknown",
-    ].join("|");
-    return crypto.createHash("sha256").update(info).digest("hex").substring(0, 32);
-}
-export function getTrialStatus() {
-    const trial = loadTrialInfo();
-    if (!trial) {
-        return { remaining: TRIAL_LIMIT, used: 0, expired: false };
-    }
-    // Verify machine ID matches (prevent copying trial.json to new machines)
-    const currentMachineId = getMachineIdForTrial();
-    if (trial.machineId !== currentMachineId) {
-        return { remaining: TRIAL_LIMIT, used: 0, expired: false };
-    }
-    const remaining = Math.max(0, TRIAL_LIMIT - trial.usageCount);
-    return {
-        remaining,
-        used: trial.usageCount,
-        expired: remaining === 0,
-    };
-}
-export function incrementTrialUsage() {
-    const machineId = getMachineIdForTrial();
-    let trial = loadTrialInfo();
-    // Initialize trial if needed
-    if (!trial || trial.machineId !== machineId) {
-        trial = {
-            usageCount: 0,
-            firstUsedAt: new Date().toISOString(),
-            lastUsedAt: new Date().toISOString(),
-            machineId,
-        };
-    }
-    // Check if trial expired
-    if (trial.usageCount >= TRIAL_LIMIT) {
-        return {
-            allowed: false,
-            remaining: 0,
-            message: `🔒 Trial expired! You've used all ${TRIAL_LIMIT} trial requests.
-
-To continue using Mobile Dev MCP, purchase a license:
-
-┌─────────────────────────────────────────┐
-│  Basic Solo    $6/month                 │
-│  → 13 core tools, 50 log lines          │
-├─────────────────────────────────────────┤
-│  Advanced Solo $12/month (or $99/year)  │
-│  → All 18 tools, unlimited logs         │
-│  → Real-time streaming, multi-device    │
-└─────────────────────────────────────────┘
-
-Purchase at: https://mobile-dev-mcp.com
-Then use 'set_license_key' to activate.`,
-        };
+        return { tier: "free", valid: true };
     }
-    // Increment usage
-    trial.usageCount++;
-    trial.lastUsedAt = new Date().toISOString();
-    saveTrialInfo(trial);
-    const remaining = TRIAL_LIMIT - trial.usageCount;
-    return {
-        allowed: true,
-        remaining,
-    };
 }
-// ============================================================================
-// API VALIDATION
-// ============================================================================
-async function validateWithApi(licenseKey, apiEndpoint) {
-    try {
-        const response = await fetch(`${apiEndpoint}/validate`, {
+async function validateWithLemonSqueezy(licenseKey) {
+    return new Promise((resolve) => {
+        const machineId = getMachineId();
+        const postData = JSON.stringify({
+            license_key: licenseKey,
+            instance_id: machineId,
+        });
+        const url = new URL(LICENSE_API_URL);
+        const req = https.request({
+            hostname: url.hostname,
+            path: url.pathname,
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
+                "Content-Length": postData.length,
             },
-            body: JSON.stringify({
-                license_key: licenseKey,
-                instance_id: getMachineId(),
-            }),
+        }, (res) => {
+            let data = "";
+            const MAX_RESPONSE_SIZE = 1024 * 1024; // 1MB limit to prevent DoS
+            res.on("data", (chunk) => {
+                data += chunk;
+                // Abort if response is too large (potential DoS)
+                if (data.length > MAX_RESPONSE_SIZE) {
+                    req.destroy();
+                    resolve(null);
+                }
+            });
+            res.on("end", () => {
+                try {
+                    const response = JSON.parse(data);
+                    if (response.valid) {
+                        const tier = mapProductToTier(response.meta?.product_name || "");
+                        const info = {
+                            tier,
+                            valid: true,
+                            licenseKey,
+                            expiresAt: response.license_key?.expires_at,
+                        };
+                        saveLicenseCache({
+                            tier,
+                            licenseKey,
+                            expiresAt: response.license_key?.expires_at,
+                            lastValidated: Date.now(),
+                        });
+                        resolve(info);
+                    }
+                    else {
+                        resolve(null);
+                    }
+                }
+                catch {
+                    resolve(null);
+                }
+            });
         });
-        if (!response.ok) {
-            console.error("License API returned status:", response.status);
-            return null;
-        }
-        const data = (await response.json());
-        if (data.valid) {
-            // Determine tier from product/variant name
-            let tier = data.tier || "basic";
-            // Check variant name for tier hints
-            const variantName = data.meta?.variant_name?.toLowerCase() || "";
-            const productName = data.meta?.product_name?.toLowerCase() || "";
-            if (variantName.includes("advanced") ||
-                productName.includes("advanced")) {
-                tier = "advanced";
-            }
-            else if (variantName.includes("basic") ||
-                productName.includes("basic")) {
-                tier = "basic";
-            }
-            return {
-                key: licenseKey,
-                valid: true,
-                tier,
-                email: data.meta?.customer_email,
-                validatedAt: new Date().toISOString(),
-                expiresAt: data.license_key?.expires_at || undefined,
-            };
-        }
-        return {
-            key: licenseKey,
-            valid: false,
-            tier: "trial",
-            validatedAt: new Date().toISOString(),
-        };
-    }
-    catch (error) {
-        console.error("License validation API error:", error);
-        return null;
-    }
+        req.on("error", () => resolve(null));
+        req.setTimeout(5000, () => {
+            req.destroy();
+            resolve(null);
+        });
+        req.write(postData);
+        req.end();
+    });
 }
-// ============================================================================
-// MAIN LICENSE CHECK
-// ============================================================================
-let cachedLicenseResult = null;
-export async function checkLicense() {
-    // Return cached result if we've already checked this session
-    if (cachedLicenseResult) {
-        return cachedLicenseResult;
-    }
-    const config = loadConfig();
-    // No license key configured - trial mode
-    if (!config.licenseKey) {
-        cachedLicenseResult = {
-            key: "",
-            valid: false,
-            tier: "trial",
-            validatedAt: new Date().toISOString(),
-        };
-        return cachedLicenseResult;
-    }
-    // Check local cache first
-    const cached = loadLicenseCache();
-    if (cached && cached.key === config.licenseKey) {
-        if (cached.valid && isCacheFresh(cached)) {
-            cachedLicenseResult = cached;
-            return cached;
-        }
-    }
-    // Try to validate with API
-    const apiResult = await validateWithApi(config.licenseKey, config.apiEndpoint);
-    if (apiResult) {
-        saveLicenseCache(apiResult);
-        cachedLicenseResult = apiResult;
-        return apiResult;
+function mapProductToTier(productName) {
+    const name = productName.toLowerCase();
+    // Any paid product maps to advanced tier
+    if (name.includes("advanced") || name.includes("pro") || name.includes("basic")) {
+        return "advanced";
     }
-    // API is down - check if we have a valid cached license within grace period
-    if (cached && cached.valid && isWithinGracePeriod(cached)) {
-        console.error("License API unreachable, using cached license (grace period)");
-        cachedLicenseResult = cached;
-        return cached;
-    }
-    // No valid cache, API down - fall back to trial
-    cachedLicenseResult = {
-        key: config.licenseKey,
-        valid: false,
-        tier: "trial",
-        validatedAt: new Date().toISOString(),
-    };
-    return cachedLicenseResult;
+    return "free";
 }
 // ============================================================================
-// FEATURE GATING
+// TOOL ACCESS CONTROL
 // ============================================================================
-export function isAdvancedTool(toolName) {
-    return ADVANCED_TOOLS.includes(toolName);
-}
-export function isBasicTool(toolName) {
-    return BASIC_TOOLS.includes(toolName);
-}
-export async function canUseTool(toolName) {
-    const license = await checkLicense();
-    // Advanced tools require Advanced tier
-    if (isAdvancedTool(toolName)) {
-        return license.valid && license.tier === "advanced";
-    }
-    // Basic tools require Basic or Advanced tier
-    if (isBasicTool(toolName)) {
-        return license.valid && (license.tier === "basic" || license.tier === "advanced");
-    }
-    // Unknown tool - allow (might be a new tool)
-    return true;
-}
-export async function requireAdvanced(toolName) {
-    const license = await checkLicense();
-    // Advanced license holders always allowed
-    if (license.valid && license.tier === "advanced") {
-        return { allowed: true };
-    }
-    // Trial users can try Advanced tools (uses trial quota)
-    if (!license.valid || license.tier === "trial") {
-        const trialResult = incrementTrialUsage();
-        if (!trialResult.allowed) {
-            return {
-                allowed: false,
-                message: trialResult.message,
-            };
-        }
-        // Trial still has requests - allow with reminder
-        if (trialResult.remaining <= 10) {
-            return {
-                allowed: true,
-                message: `⚠️ Trial: ${trialResult.remaining} requests remaining. This is an Advanced feature - upgrade to keep using it!`,
-            };
+export function canAccessTool(toolName, tier) {
+    // Free tools are always accessible
+    if (FREE_TOOLS.includes(toolName)) {
+        return true;
+    }
+    // Advanced tools require advanced tier
+    if (tier === "advanced") {
+        if (ADVANCED_TOOLS.includes(toolName)) {
+            return true;
         }
-        return { allowed: true };
     }
-    // Basic tier users cannot use Advanced tools
-    return {
-        allowed: false,
-        message: `🔒 "${toolName}" requires Advanced tier.
-
-Your current tier: BASIC
-
-Upgrade to Advanced for:
-- Real-time log streaming
-- Screenshot history
-- Multi-device support (3 devices)
-- Error watching
-- Unlimited log lines
-- Device interaction (tap, type, swipe)
-
-Pricing: $8/week, $12/month, or $99/year
-
-Upgrade at: https://mobile-dev-mcp.com`,
-    };
+    return false;
 }
-export async function requireBasic(toolName) {
-    const license = await checkLicense();
-    // Licensed users can always use basic tools
-    if (license.valid) {
-        return { allowed: true };
-    }
-    // Trial users - check trial status
-    const trialResult = incrementTrialUsage();
-    if (!trialResult.allowed) {
-        return {
-            allowed: false,
-            message: trialResult.message,
-        };
-    }
-    // Trial still has requests - allow with reminder
-    if (trialResult.remaining <= 10) {
-        return {
-            allowed: true,
-            message: `⚠️ Trial: ${trialResult.remaining} requests remaining. Purchase a license to continue uninterrupted.`,
-        };
-    }
-    return { allowed: true };
+export function isFreeTool(toolName) {
+    return FREE_TOOLS.includes(toolName);
 }
-export function getTierLimits(tier) {
-    return TIER_LIMITS[tier];
+export function isAdvancedOnlyTool(toolName) {
+    return ADVANCED_TOOLS.includes(toolName) && !FREE_TOOLS.includes(toolName);
 }
-export async function getMaxLogLines() {
-    const license = await checkLicense();
-    return TIER_LIMITS[license.tier].maxLogLines;
+export function getMaxLogLines(tier) {
+    return TIER_LIMITS[tier]?.maxLogLines || 50;
+}
+export function getMaxDevices(tier) {
+    return TIER_LIMITS[tier]?.maxDevices || 1;
 }
 // ============================================================================
-// LICENSE INFO TOOL
+// LICENSE TOOLS (exposed via MCP)
 // ============================================================================
 export async function getLicenseStatus() {
     const license = await checkLicense();
-    const config = loadConfig();
-    if (!config.licenseKey) {
-        const trialStatus = getTrialStatus();
-        if (trialStatus.expired) {
-            return `📋 License Status: TRIAL EXPIRED
-
-You've used all ${TRIAL_LIMIT} trial requests.
-
-┌─────────────────────────────────────────┐
-│  Basic Solo    $6/mo      → Core tools  │
-│  Advanced Solo $12/mo     → All features│
-│                $8/wk or $99/yr          │
-└─────────────────────────────────────────┘
-
-Purchase at: https://mobile-dev-mcp.com
-Then use 'set_license_key' to activate.`;
-        }
-        return `📋 License Status: TRIAL
-
-Trial requests remaining: ${trialStatus.remaining}/${TRIAL_LIMIT}
-Trial requests used: ${trialStatus.used}
-
-┌─────────────────────────────────────────┐
-│  Basic Solo    $6/mo      → Core tools  │
-│  Advanced Solo $12/mo     → All features│
-│                $8/wk or $99/yr          │
-└─────────────────────────────────────────┘
-
-Purchase at: https://mobile-dev-mcp.com
-Then use 'set_license_key' to activate.`;
-    }
-    if (!license.valid) {
-        return `📋 License Status: INVALID
-
-License key: ${maskLicenseKey(config.licenseKey)}
-Status: Invalid or expired
-
-Please check your license key or purchase a new one.
-https://mobile-dev-mcp.com`;
-    }
-    const tierEmoji = license.tier === "advanced" ? "⭐" : "✓";
     const limits = TIER_LIMITS[license.tier];
-    return `📋 License Status: ${license.tier.toUpperCase()} ${tierEmoji}
-
-License key: ${maskLicenseKey(license.key)}
-Email: ${license.email || "N/A"}
-Valid until: ${license.expiresAt || "Active subscription"}
-Last validated: ${license.validatedAt}
-
-Your limits:
-- Max log lines: ${limits.maxLogLines === Infinity ? "Unlimited" : limits.maxLogLines}
-- Max devices: ${limits.maxDevices}
-- Screenshot history: ${limits.screenshotHistory || "Not available"}
-
-${license.tier === "basic" ? "\n💡 Upgrade to Advanced for real-time streaming & multi-device support!" : "All features unlocked! 🎉"}`;
-}
-function maskLicenseKey(key) {
-    if (key.length < 8)
-        return "****";
-    return key.substring(0, 4) + "****" + key.substring(key.length - 4);
-}
-export const licenseTools = [
-    {
-        name: "get_license_status",
-        description: "Check your current license status and tier (free/basic/advanced)",
-        inputSchema: {
-            type: "object",
-            properties: {},
-        },
-    },
-    {
-        name: "set_license_key",
-        description: "Set or update your license key to unlock paid features",
-        inputSchema: {
-            type: "object",
-            properties: {
-                licenseKey: {
-                    type: "string",
-                    description: "Your license key from mobile-dev-mcp.com",
-                },
-            },
-            required: ["licenseKey"],
+    return JSON.stringify({
+        tier: license.tier.toUpperCase(),
+        valid: license.valid,
+        expiresAt: license.expiresAt || "N/A",
+        features: {
+            maxLogLines: limits?.maxLogLines || 50,
+            maxDevices: limits?.maxDevices || 1,
+            tools: license.tier === "advanced" ? 21 : 8,
         },
-    },
-];
-export async function handleLicenseTool(name, args) {
-    switch (name) {
-        case "get_license_status":
-            return getLicenseStatus();
-        case "set_license_key":
-            const key = args.licenseKey;
-            if (!key || key.length < 10) {
-                return "Invalid license key format. Keys should look like: lk_XXXXX...";
-            }
-            setLicenseKey(key);
-            // Force revalidation
-            cachedLicenseResult = null;
-            const status = await checkLicense();
-            if (status.valid) {
-                return `✅ License activated successfully!
-
-Tier: ${status.tier.toUpperCase()}
-${status.tier === "advanced" ? "All features unlocked!" : "Basic features unlocked!"}
-
-Use 'get_license_status' to see your limits.`;
-            }
-            else {
-                return `❌ License key is invalid or expired.
-
-Please check your key or contact support.
-https://mobile-dev-mcp.com`;
-            }
-        default:
-            return `Unknown license tool: ${name}`;
+        upgrade: license.tier === "free" ? {
+            url: "https://mobiledevmcp.dev/pricing",
+            price: "$18/month",
+            features: ["UI inspection", "Screen analysis", "Multi-device support"],
+        } : null,
+    }, null, 2);
+}
+export async function setLicenseKey(licenseKey) {
+    if (!licenseKey || licenseKey.trim() === "") {
+        return JSON.stringify({ success: false, error: "License key is required" });
+    }
+    // Basic format validation
+    const key = licenseKey.trim();
+    if (key.length < 10 || key.length > 100) {
+        return JSON.stringify({ success: false, error: "Invalid license key format" });
+    }
+    const validated = await validateWithLemonSqueezy(key);
+    if (validated) {
+        return JSON.stringify({
+            success: true,
+            tier: validated.tier.toUpperCase(),
+            expiresAt: validated.expiresAt || "N/A",
+            message: `License activated! You now have ${validated.tier.toUpperCase()} tier access with all 21 tools.`,
+        });
     }
+    return JSON.stringify({
+        success: false,
+        error: "Invalid license key. Please check your key and try again.",
+    });
 }
 //# sourceMappingURL=license.js.map