kaven-cli 0.1.0-alpha.1 → 0.3.0

package/dist/core/ConfigManager.js

@@ -0,0 +1,165 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configManager = exports.ConfigManager = exports.configSchema = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
+const zod_1 = require("zod");
+const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), ".kaven");
+const CONFIG_PATH = path_1.default.join(CONFIG_DIR, "config.json");
+exports.configSchema = zod_1.z.object({
+    registry: zod_1.z.string().url().default("https://marketplace.kaven.sh"),
+    telemetry: zod_1.z.boolean().default(true),
+    theme: zod_1.z.enum(["light", "dark"]).default("dark"),
+    locale: zod_1.z.string().default("en-US"),
+    // Custom registry support
+    customRegistry: zod_1.z.string().url().optional(),
+    // For storing user preferences
+    lastLogin: zod_1.z.string().datetime().optional(),
+    projectDefaults: zod_1.z
+        .object({
+        dbUrl: zod_1.z.string().optional(),
+        emailProvider: zod_1.z.enum(["postmark", "resend", "ses", "smtp"]).optional(),
+        locale: zod_1.z.string().optional(),
+        currency: zod_1.z.string().optional(),
+    })
+        .optional(),
+});
+class ConfigManager {
+    constructor() {
+        this.config = {
+            registry: "https://marketplace.kaven.sh",
+            telemetry: true,
+            theme: "dark",
+            locale: "en-US",
+        };
+    }
+    async initialize() {
+        await fs_extra_1.default.ensureDir(CONFIG_DIR);
+        if (await fs_extra_1.default.pathExists(CONFIG_PATH)) {
+            try {
+                const raw = await fs_extra_1.default.readJson(CONFIG_PATH);
+                const parsed = exports.configSchema.safeParse(raw);
+                if (parsed.success) {
+                    this.config = parsed.data;
+                }
+                else {
+                    // If validation fails, use defaults
+                    this.config = {
+                        registry: "https://marketplace.kaven.sh",
+                        telemetry: true,
+                        theme: "dark",
+                        locale: "en-US",
+                    };
+                }
+            }
+            catch {
+                // If file is corrupted, start fresh
+                this.config = {
+                    registry: "https://marketplace.kaven.sh",
+                    telemetry: true,
+                    theme: "dark",
+                    locale: "en-US",
+                };
+            }
+        }
+        else {
+            // Initialize with defaults
+            this.config = {
+                registry: "https://marketplace.kaven.sh",
+                telemetry: true,
+                theme: "dark",
+                locale: "en-US",
+            };
+            await this.persist();
+        }
+    }
+    /**
+     * Get config value with env var override support
+     * Priority: ENV VAR > config file > CLI arg > default
+     */
+    get(key, envVarName) {
+        // Check environment variable override
+        if (envVarName) {
+            const envValue = process.env[envVarName];
+            if (envValue !== undefined) {
+                return envValue;
+            }
+        }
+        // Check config file
+        const value = this.config[key];
+        if (value !== undefined) {
+            return value;
+        }
+        // Return default from schema
+        const defaults = exports.configSchema.parse({});
+        return defaults[key];
+    }
+    /**
+     * Set config value and persist to disk
+     */
+    async set(key, value) {
+        const updateObj = { [key]: value };
+        const updated = exports.configSchema.safeParse({ ...this.config, ...updateObj });
+        if (!updated.success) {
+            const errors = updated.error.issues
+                .map((issue) => `${issue.path.join(".")}: ${issue.message}`)
+                .join(", ");
+            throw new Error(`Invalid config: ${errors}`);
+        }
+        this.config = updated.data;
+        await this.persist();
+    }
+    /**
+     * Get all config
+     */
+    getAll() {
+        return { ...this.config };
+    }
+    /**
+     * Reset config to defaults
+     */
+    async reset() {
+        this.config = {
+            registry: "https://marketplace.kaven.sh",
+            telemetry: true,
+            theme: "dark",
+            locale: "en-US",
+        };
+        await this.persist();
+    }
+    /**
+     * Persist config to disk
+     */
+    async persist() {
+        await fs_extra_1.default.ensureDir(CONFIG_DIR);
+        await fs_extra_1.default.writeJson(CONFIG_PATH, this.config, { spaces: 2 });
+    }
+    /**
+     * Get registry URL (custom or default)
+     */
+    getRegistry() {
+        return (this.config.customRegistry || this.config.registry || "https://marketplace.kaven.sh");
+    }
+    /**
+     * Check if telemetry is enabled (can be overridden by env var)
+     */
+    isTelemetryEnabled() {
+        if (process.env.KAVEN_TELEMETRY === "0") {
+            return false;
+        }
+        return this.config.telemetry !== false;
+    }
+    /**
+     * Get config directory path
+     */
+    getConfigDir() {
+        return CONFIG_DIR;
+    }
+}
+exports.ConfigManager = ConfigManager;
+// Export singleton instance
+exports.configManager = new ConfigManager();

package/dist/core/EnvManager.js

@@ -0,0 +1,196 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const chalk_1 = __importDefault(require("chalk"));
+class EnvManager {
+    async injectEnvVars(moduleSlug, envVars, options) {
+        if (options.skipEnv || !envVars || envVars.length === 0) {
+            return { added: 0, skipped: 0 };
+        }
+        const envFilePath = path.join(options.projectDir, options.envFile ?? '.env');
+        const existingContent = this.readEnvFile(envFilePath);
+        const existingVars = this.parseEnvFile(existingContent);
+        const newVars = [];
+        let skipped = 0;
+        console.log(chalk_1.default.bold(`\n  Environment variables for '${moduleSlug}':\n`));
+        for (const envDef of envVars) {
+            if (existingVars.has(envDef.name)) {
+                console.log(chalk_1.default.dim(`  ${envDef.name} — already set, skipping`));
+                skipped++;
+                continue;
+            }
+            let value;
+            if (envDef.sensitive) {
+                value = await this.promptPassword(`  ${envDef.name} (${envDef.description})${envDef.default ? ' [****]' : ''}: `);
+                if (!value && envDef.default)
+                    value = envDef.default;
+            }
+            else {
+                const defaultHint = envDef.default ? ` [${envDef.default}]` : '';
+                value = await this.promptInput(`  ${envDef.name} (${envDef.description})${defaultHint}: `, envDef.default);
+            }
+            if (envDef.required && !value) {
+                console.log(chalk_1.default.yellow(`  ${envDef.name} is required.`));
+                value = envDef.sensitive
+                    ? await this.promptPassword(`  ${envDef.name}: `)
+                    : await this.promptInput(`  ${envDef.name}: `);
+                if (!value) {
+                    console.log(chalk_1.default.yellow(`  Skipping ${envDef.name} — set it manually in .env`));
+                    skipped++;
+                    continue;
+                }
+            }
+            newVars.push({ name: envDef.name, value });
+        }
+        if (newVars.length === 0) {
+            console.log(chalk_1.default.dim('  No new environment variables to add.'));
+            return { added: 0, skipped };
+        }
+        const markerBlock = this.buildMarkerBlock(moduleSlug, newVars);
+        this.appendToEnvFile(envFilePath, existingContent, markerBlock);
+        console.log(chalk_1.default.green(`\n  Added ${newVars.length} environment variable(s) to ${options.envFile ?? '.env'}`));
+        return { added: newVars.length, skipped };
+    }
+    removeEnvVars(moduleSlug, options) {
+        const envFiles = ['.env', '.env.local', '.env.development', '.env.production'];
+        if (options.envFile)
+            envFiles.unshift(options.envFile);
+        let totalRemoved = 0;
+        for (const envFile of envFiles) {
+            const envFilePath = path.join(options.projectDir, envFile);
+            if (!fs.existsSync(envFilePath))
+                continue;
+            const content = fs.readFileSync(envFilePath, 'utf-8');
+            const beginMarker = `# [KAVEN_MODULE:${moduleSlug} BEGIN]`;
+            const endMarker = `# [KAVEN_MODULE:${moduleSlug} END]`;
+            const beginIdx = content.indexOf(beginMarker);
+            const endIdx = content.indexOf(endMarker);
+            if (beginIdx === -1 || endIdx === -1)
+                continue;
+            const block = content.substring(beginIdx, endIdx + endMarker.length);
+            const varCount = block.split('\n').filter(l => /^[A-Z_]+=/.test(l)).length;
+            const before = content.substring(0, beginIdx).replace(/\n+$/, '\n');
+            const after = content.substring(endIdx + endMarker.length + 1);
+            fs.writeFileSync(envFilePath, before + after);
+            totalRemoved += varCount;
+            if (varCount > 0) {
+                console.log(chalk_1.default.dim(`  Removed ${varCount} env var(s) from ${envFile}`));
+            }
+        }
+        return totalRemoved;
+    }
+    readEnvFile(filePath) {
+        try {
+            return fs.readFileSync(filePath, 'utf-8');
+        }
+        catch {
+            return '';
+        }
+    }
+    parseEnvFile(content) {
+        const vars = new Map();
+        for (const line of content.split('\n')) {
+            const match = line.match(/^([A-Z_][A-Z0-9_]*)=(.*)$/);
+            if (match)
+                vars.set(match[1], match[2]);
+        }
+        return vars;
+    }
+    buildMarkerBlock(moduleSlug, vars) {
+        return [
+            `# [KAVEN_MODULE:${moduleSlug} BEGIN]`,
+            ...vars.map(v => `${v.name}=${v.value}`),
+            `# [KAVEN_MODULE:${moduleSlug} END]`,
+        ].join('\n');
+    }
+    appendToEnvFile(filePath, existingContent, block) {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        const separator = existingContent.endsWith('\n') || existingContent === '' ? '\n' : '\n\n';
+        fs.writeFileSync(filePath, existingContent + separator + block + '\n');
+    }
+    promptInput(message, defaultValue) {
+        return new Promise(resolve => {
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            rl.question(message, answer => {
+                rl.close();
+                resolve(answer || defaultValue || '');
+            });
+        });
+    }
+    promptPassword(message) {
+        return new Promise(resolve => {
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            // Hide input by listening to keypress but readline doesn't natively support this
+            // For simplicity, use standard prompt (production would use a proper password lib)
+            process.stdout.write(message);
+            process.stdin.setRawMode?.(true);
+            process.stdin.resume();
+            let password = '';
+            const handler = (key) => {
+                const char = key.toString();
+                if (char === '\r' || char === '\n') {
+                    process.stdin.setRawMode?.(false);
+                    process.stdin.pause();
+                    process.stdin.removeListener('data', handler);
+                    process.stdout.write('\n');
+                    rl.close();
+                    resolve(password);
+                }
+                else if (char === '\u0003') {
+                    process.exit();
+                }
+                else if (char === '\u007f') {
+                    password = password.slice(0, -1);
+                    process.stdout.clearLine(0);
+                    process.stdout.cursorTo(0);
+                    process.stdout.write(message + '*'.repeat(password.length));
+                }
+                else {
+                    password += char;
+                    process.stdout.write('*');
+                }
+            };
+            process.stdin.on('data', handler);
+        });
+    }
+}
+exports.EnvManager = EnvManager;

package/dist/core/ErrorRecovery.js

@@ -0,0 +1,191 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorRecovery = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+/**
+ * C2.7: Error recovery and validation system
+ */
+class ErrorRecovery {
+    constructor() {
+        this.backupDir = path_1.default.join(os_1.default.homedir(), ".kaven", "backups");
+    }
+    /**
+     * Create a backup of the project state before operation
+     */
+    async createBackup(projectPath, operationName) {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, "-").substring(0, 19);
+        const backupName = `${operationName}-${timestamp}`;
+        const backupPath = path_1.default.join(this.backupDir, backupName);
+        try {
+            await fs_extra_1.default.ensureDir(this.backupDir);
+            // Backup key files
+            const files = ["package.json", "pnpm-lock.yaml", ".env", "prisma/schema.prisma"];
+            for (const file of files) {
+                const source = path_1.default.join(projectPath, file);
+                const dest = path_1.default.join(backupPath, file);
+                if (await fs_extra_1.default.pathExists(source)) {
+                    await fs_extra_1.default.ensureDir(path_1.default.dirname(dest));
+                    await fs_extra_1.default.copy(source, dest);
+                }
+            }
+            return backupPath;
+        }
+        catch (error) {
+            throw new Error(`Failed to create backup: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Rollback from backup
+     */
+    async rollback(projectPath, backupPath) {
+        try {
+            if (!(await fs_extra_1.default.pathExists(backupPath))) {
+                throw new Error(`Backup not found at ${backupPath}`);
+            }
+            const files = ["package.json", "pnpm-lock.yaml", ".env", "prisma/schema.prisma"];
+            for (const file of files) {
+                const source = path_1.default.join(backupPath, file);
+                const dest = path_1.default.join(projectPath, file);
+                if (await fs_extra_1.default.pathExists(source)) {
+                    await fs_extra_1.default.copy(source, dest, { overwrite: true });
+                }
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to rollback: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Pre-operation validation
+     */
+    async validatePreConditions(projectPath) {
+        const errors = [];
+        // Check package.json exists
+        if (!(await fs_extra_1.default.pathExists(path_1.default.join(projectPath, "package.json")))) {
+            errors.push("package.json not found");
+        }
+        // Check node_modules exists
+        if (!(await fs_extra_1.default.pathExists(path_1.default.join(projectPath, "node_modules")))) {
+            errors.push("Dependencies not installed. Run: pnpm install");
+        }
+        // Check if git repo (for safety)
+        const gitDir = path_1.default.join(projectPath, ".git");
+        if (!(await fs_extra_1.default.pathExists(gitDir))) {
+            errors.push("Not a git repository. Initialize with: git init && git add . && git commit");
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    /**
+     * Post-operation health check
+     */
+    async validatePostConditions(projectPath) {
+        const issues = [];
+        // Check package.json is valid JSON
+        try {
+            const packageJson = await fs_extra_1.default.readJson(path_1.default.join(projectPath, "package.json"));
+            if (!packageJson.name) {
+                issues.push("package.json missing name field");
+            }
+        }
+        catch {
+            issues.push("package.json is invalid JSON");
+        }
+        // Check prisma schema if it exists
+        const schemaPath = path_1.default.join(projectPath, "prisma", "schema.prisma");
+        if (await fs_extra_1.default.pathExists(schemaPath)) {
+            const content = await fs_extra_1.default.readFile(schemaPath, "utf-8");
+            if (!content.includes("datasource db")) {
+                issues.push("prisma/schema.prisma missing datasource");
+            }
+        }
+        // Check .env exists or .env.example exists
+        const envPath = path_1.default.join(projectPath, ".env");
+        const envExamplePath = path_1.default.join(projectPath, ".env.example");
+        if (!(await fs_extra_1.default.pathExists(envPath)) && !(await fs_extra_1.default.pathExists(envExamplePath))) {
+            issues.push("No .env or .env.example file found");
+        }
+        return {
+            healthy: issues.length === 0,
+            issues,
+        };
+    }
+    /**
+     * Run operation with automatic rollback on failure
+     */
+    async withRollback(projectPath, operationName, operation) {
+        // Pre-validation
+        const preCheck = await this.validatePreConditions(projectPath);
+        if (!preCheck.valid) {
+            throw new Error(`Pre-conditions not met:\n${preCheck.errors.map((e) => `  - ${e}`).join("\n")}`);
+        }
+        // Create backup
+        const spinner = (0, ora_1.default)("Creating backup...").start();
+        const backupPath = await this.createBackup(projectPath, operationName);
+        spinner.succeed(`Backup created at ${backupPath}`);
+        try {
+            // Run operation
+            const result = await operation();
+            // Post-validation
+            const postCheck = await this.validatePostConditions(projectPath);
+            if (!postCheck.healthy) {
+                spinner.warn("Post-operation issues detected:");
+                for (const issue of postCheck.issues) {
+                    console.log(chalk_1.default.yellow(`  ⚠ ${issue}`));
+                }
+            }
+            return result;
+        }
+        catch (error) {
+            // Rollback on failure
+            spinner.start("Rolling back...");
+            try {
+                await this.rollback(projectPath, backupPath);
+                spinner.succeed("Rolled back successfully");
+            }
+            catch (rollbackError) {
+                spinner.fail(`Rollback failed: ${rollbackError}`);
+                console.error(chalk_1.default.red("Manual intervention required:"));
+                console.error(chalk_1.default.gray(`Backup available at: ${backupPath}`));
+            }
+            throw error;
+        }
+    }
+    /**
+     * List available backups
+     */
+    async listBackups() {
+        if (!(await fs_extra_1.default.pathExists(this.backupDir))) {
+            return [];
+        }
+        const entries = await fs_extra_1.default.readdir(this.backupDir);
+        return entries.map((name) => ({
+            name,
+            path: path_1.default.join(this.backupDir, name),
+            timestamp: name.substring(name.lastIndexOf("-") + 1),
+        }));
+    }
+    /**
+     * Clean old backups (keep last N)
+     */
+    async cleanupBackups(keepCount = 5) {
+        const backups = await this.listBackups();
+        if (backups.length <= keepCount) {
+            return;
+        }
+        const toDelete = backups.slice(keepCount);
+        for (const backup of toDelete) {
+            await fs_extra_1.default.remove(backup.path);
+        }
+    }
+}
+exports.ErrorRecovery = ErrorRecovery;

package/dist/core/LicenseService.js

@@ -0,0 +1,118 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LicenseService = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const CACHE_FILE = path_1.default.join(os_1.default.homedir(), '.kaven', 'cache', 'licenses.json');
+const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
+class LicenseService {
+    constructor() {
+        this.cacheDir = path_1.default.join(os_1.default.homedir(), '.kaven', 'cache');
+    }
+    /** Luhn mod-31 checksum format check (KAVEN-{TIER}-{8RANDOM}-{CHECKSUM}) */
+    isValidFormat(licenseKey) {
+        const pattern = /^KAVEN-(STARTER|COMPLETE|PRO|ENTERPRISE)-[A-Z0-9]{8}-[A-Z0-9]{2}$/;
+        return pattern.test(licenseKey);
+    }
+    async readCache() {
+        try {
+            const raw = await promises_1.default.readFile(CACHE_FILE, 'utf-8');
+            return JSON.parse(raw);
+        }
+        catch {
+            return {};
+        }
+    }
+    async writeCache(cache) {
+        await promises_1.default.mkdir(this.cacheDir, { recursive: true });
+        await promises_1.default.writeFile(CACHE_FILE, JSON.stringify(cache, null, 2), 'utf-8');
+    }
+    isCacheValid(entry) {
+        return Date.now() - entry.validatedAt < CACHE_TTL_MS;
+    }
+    async getCached(licenseKey) {
+        const cache = await this.readCache();
+        const entry = cache[licenseKey];
+        if (entry && this.isCacheValid(entry))
+            return entry;
+        return null;
+    }
+    async setCached(entry) {
+        const cache = await this.readCache();
+        cache[entry.key] = { ...entry, validatedAt: Date.now() };
+        await this.writeCache(cache);
+    }
+    async validateLicense(licenseKey, requiredTier) {
+        // 1. Check cache first
+        const cached = await this.getCached(licenseKey);
+        if (cached) {
+            return { valid: true, tier: cached.tier, expiresAt: cached.expiresAt, source: 'cache' };
+        }
+        // 2. Format check (offline Luhn-style)
+        if (!this.isValidFormat(licenseKey)) {
+            throw new Error('Invalid license key format');
+        }
+        // 3. API validation
+        const { MarketplaceClient } = await Promise.resolve().then(() => __importStar(require('../infrastructure/MarketplaceClient.js')));
+        const client = new MarketplaceClient();
+        const result = await client.validateLicense(licenseKey, requiredTier);
+        // Cache on success
+        await this.setCached({
+            key: licenseKey,
+            tier: result.tier,
+            expiresAt: result.expiresAt,
+            validatedAt: Date.now(),
+        });
+        return { ...result, source: 'api' };
+    }
+    async getLicenseStatus(licenseKey) {
+        const { MarketplaceClient } = await Promise.resolve().then(() => __importStar(require('../infrastructure/MarketplaceClient.js')));
+        const client = new MarketplaceClient();
+        return client.getLicenseStatus(licenseKey);
+    }
+    tierLevel(tier) {
+        const levels = { STARTER: 1, COMPLETE: 2, PRO: 3, ENTERPRISE: 4 };
+        return levels[tier.toUpperCase()] ?? 0;
+    }
+    userHasRequiredTier(userTier, requiredTier) {
+        return this.tierLevel(userTier) >= this.tierLevel(requiredTier);
+    }
+}
+exports.LicenseService = LicenseService;