kaven-cli 0.1.0-alpha.1 → 0.3.0

package/dist/commands/upgrade/index.js

@@ -0,0 +1,218 @@
+"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.upgradeInstall = exports.upgradeCheck = void 0;
+exports.upgradeCommand = upgradeCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const open_1 = __importDefault(require("open"));
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
+const AuthService_1 = require("../../core/AuthService");
+const MarketplaceClient_1 = require("../../infrastructure/MarketplaceClient");
+const check_1 = require("./check");
+Object.defineProperty(exports, "upgradeCheck", { enumerable: true, get: function () { return check_1.upgradeCheck; } });
+Object.defineProperty(exports, "upgradeInstall", { enumerable: true, get: function () { return check_1.upgradeInstall; } });
+const LICENSE_PATH = path_1.default.join(os_1.default.homedir(), ".kaven", "license.json");
+const TIERS = ["starter", "complete", "pro", "enterprise"];
+const TIER_LABELS = {
+    starter: "Starter",
+    complete: "Complete",
+    pro: "Pro",
+    enterprise: "Enterprise",
+};
+const POLL_INTERVAL_MS = 5000;
+const MAX_POLLS = 120; // 10 minutes
+async function loadLicenseKey() {
+    if (!(await fs_extra_1.default.pathExists(LICENSE_PATH)))
+        return null;
+    try {
+        const data = await fs_extra_1.default.readJson(LICENSE_PATH);
+        return data.key || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function saveLicenseTier(tier) {
+    let existing = {};
+    if (await fs_extra_1.default.pathExists(LICENSE_PATH)) {
+        try {
+            existing = await fs_extra_1.default.readJson(LICENSE_PATH);
+        }
+        catch {
+            // ignore
+        }
+    }
+    await fs_extra_1.default.ensureDir(path_1.default.dirname(LICENSE_PATH));
+    await fs_extra_1.default.writeJson(LICENSE_PATH, { ...existing, tier }, { spaces: 2 });
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function upgradeCommand(options) {
+    // 1. Require auth
+    const authService = new AuthService_1.AuthService();
+    try {
+        await authService.getValidToken();
+    }
+    catch {
+        console.error(chalk_1.default.red("Error: Not authenticated. Run 'kaven auth login' first."));
+        process.exit(1);
+        return;
+    }
+    // 2. Load current license key
+    const licenseKey = await loadLicenseKey();
+    if (!licenseKey) {
+        console.error(chalk_1.default.red("Error: No license found. Add your license key first with 'kaven license status'."));
+        process.exit(1);
+        return;
+    }
+    // 3. Get current tier
+    const client = new MarketplaceClient_1.MarketplaceClient(authService);
+    const tierSpinner = (0, ora_1.default)("Loading your current license...").start();
+    let currentTier;
+    try {
+        const licenseStatus = await client.getLicenseStatus(licenseKey);
+        currentTier = licenseStatus.tier.toLowerCase();
+        tierSpinner.succeed(`Current tier: ${chalk_1.default.bold(TIER_LABELS[currentTier] || currentTier)}`);
+    }
+    catch {
+        tierSpinner.fail("Could not load license status");
+        console.error(chalk_1.default.gray("Try: kaven license status"));
+        process.exit(1);
+        return;
+    }
+    // 4. Show tier comparison table (imported from license command)
+    const { printTierComparisonTable } = await Promise.resolve().then(() => __importStar(require("../license/tier-table")));
+    printTierComparisonTable(currentTier, "pro");
+    console.log();
+    // 5. Prompt target tier (exclude current tier)
+    const { select } = await Promise.resolve().then(() => __importStar(require("@inquirer/prompts")));
+    const availableTiers = TIERS.filter((t) => t !== currentTier && t !== "enterprise");
+    if (availableTiers.length === 0) {
+        console.log(chalk_1.default.yellow(`You're already on the highest available tier (${TIER_LABELS[currentTier] || currentTier}).`));
+        console.log(chalk_1.default.gray("For Enterprise plans, contact: enterprise@kaven.sh"));
+        return;
+    }
+    const targetTier = await select({
+        message: "Select target tier:",
+        choices: availableTiers.map((t) => ({
+            name: TIER_LABELS[t],
+            value: t,
+        })),
+    });
+    // 6. Guard: same tier
+    if (targetTier === currentTier) {
+        console.log(chalk_1.default.yellow(`Already on ${TIER_LABELS[currentTier] || currentTier}.`));
+        return;
+    }
+    // 7. Create checkout session
+    const checkoutSpinner = (0, ora_1.default)("Creating checkout session...").start();
+    let sessionUrl;
+    let sessionId;
+    try {
+        const session = await client.createCheckoutSession(targetTier, licenseKey);
+        sessionUrl = session.sessionUrl;
+        sessionId = session.sessionId;
+        checkoutSpinner.succeed("Checkout session created");
+    }
+    catch (error) {
+        checkoutSpinner.fail("Failed to create checkout session");
+        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
+        process.exit(1);
+        return;
+    }
+    // 8. Open browser
+    if (options.browser !== false) {
+        console.log(chalk_1.default.cyan(`Opening checkout in your browser...`));
+        console.log(chalk_1.default.gray(`URL: ${sessionUrl}`));
+        try {
+            await (0, open_1.default)(sessionUrl);
+        }
+        catch {
+            console.log(chalk_1.default.yellow("Could not open browser automatically. Open this URL manually:"));
+            console.log(chalk_1.default.cyan(sessionUrl));
+        }
+    }
+    else {
+        console.log(chalk_1.default.cyan("Open this URL to complete checkout:"));
+        console.log(chalk_1.default.bold(sessionUrl));
+    }
+    console.log();
+    // 9. Poll for checkout status
+    const pollSpinner = (0, ora_1.default)(`Waiting for payment confirmation (checking every 5s, max 10 min)...`).start();
+    for (let i = 0; i < MAX_POLLS; i++) {
+        await sleep(POLL_INTERVAL_MS);
+        const remaining = MAX_POLLS - i - 1;
+        pollSpinner.text = `Waiting for payment confirmation... (${remaining * 5}s remaining)`;
+        try {
+            const status = await client.getCheckoutStatus(sessionId);
+            if (status.status === "confirmed") {
+                pollSpinner.succeed("Payment confirmed!");
+                const newTier = status.tier || targetTier;
+                await saveLicenseTier(newTier);
+                console.log();
+                console.log(chalk_1.default.green(`✅ Successfully upgraded to ${TIER_LABELS[newTier] || newTier}!`));
+                console.log(chalk_1.default.gray("Your new features are now unlocked."));
+                return;
+            }
+            if (status.status === "cancelled") {
+                pollSpinner.fail("Checkout was cancelled.");
+                console.log(chalk_1.default.gray("No changes were made to your subscription."));
+                return;
+            }
+            if (status.status === "failed") {
+                pollSpinner.fail("Payment failed.");
+                console.log(chalk_1.default.gray("Please try again or contact support@kaven.sh"));
+                process.exit(1);
+                return;
+            }
+            // status === "pending" — continue polling
+        }
+        catch {
+            // Network hiccup — keep polling
+        }
+    }
+    // Timeout
+    pollSpinner.warn("Timed out waiting for payment confirmation.");
+    console.log();
+    console.log(chalk_1.default.yellow("If you completed payment, your upgrade may take a few minutes to activate."));
+    console.log(chalk_1.default.gray("Check your upgrade status at: https://dashboard.kaven.sh/billing"));
+}

package/dist/core/AuthService.js

@@ -1,4 +1,37 @@
 "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 };
 };
@@ -7,54 +40,214 @@ exports.AuthService = void 0;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
+/** Decode a JWT payload without verifying the signature (server's responsibility). */
+function decodeJwtPayload(token) {
+    try {
+        const parts = token.split(".");
+        if (parts.length !== 3)
+            return null;
+        // Base64url → Base64 → JSON
+        const base64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+        const padded = base64 + "=".repeat((4 - (base64.length % 4)) % 4);
+        const json = Buffer.from(padded, "base64").toString("utf8");
+        return JSON.parse(json);
+    }
+    catch {
+        return null;
+    }
+}
+/** Format a future timestamp into a human-readable "expires in X" string. */
+function formatExpiryRelative(expiresAt) {
+    const now = Date.now();
+    const expMs = new Date(expiresAt).getTime();
+    const diffSeconds = Math.max(0, Math.floor((expMs - now) / 1000));
+    if (diffSeconds === 0)
+        return "expired";
+    const hours = Math.floor(diffSeconds / 3600);
+    const minutes = Math.floor((diffSeconds % 3600) / 60);
+    if (hours > 0) {
+        return `expires in ${hours}h ${minutes}m`;
+    }
+    return `expires in ${minutes}m`;
+}
 class AuthService {
     constructor() {
         this.configPath = path_1.default.join(os_1.default.homedir(), ".kaven", "auth.json");
     }
+    /**
+     * Store complete auth tokens (new format for C1.1+)
+     */
+    async saveTokens(tokens) {
+        const configDir = path_1.default.dirname(this.configPath);
+        await fs_extra_1.default.ensureDir(configDir);
+        await fs_extra_1.default.writeJson(this.configPath, tokens, { spaces: 2 });
+        // Set restrictive permissions (0600 - owner read/write only) on Unix-like systems
+        if (process.platform !== "win32") {
+            await fs_extra_1.default.chmod(this.configPath, 0o600);
+        }
+    }
+    /**
+     * Legacy method - kept for backwards compatibility
+     * @deprecated Use saveTokens() instead
+     */
     async storeToken(token) {
         const configDir = path_1.default.dirname(this.configPath);
         await fs_extra_1.default.ensureDir(configDir);
-        // Salvar token em JSON
         await fs_extra_1.default.writeJson(this.configPath, { token }, { spaces: 2 });
-        // Definir permissões restritas (0600 - leitura/escrita apenas pelo dono) no Linux
         if (process.platform !== "win32") {
             await fs_extra_1.default.chmod(this.configPath, 0o600);
         }
     }
+    /**
+     * Get stored authentication data (new format)
+     */
+    async getAuth() {
+        if (!(await fs_extra_1.default.pathExists(this.configPath))) {
+            return null;
+        }
+        try {
+            const data = await fs_extra_1.default.readJson(this.configPath);
+            if (data.access_token) {
+                return data;
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Legacy method - kept for backwards compatibility
+     * @deprecated Use getAuth() instead
+     */
     async getToken() {
         if (!(await fs_extra_1.default.pathExists(this.configPath))) {
             return null;
         }
         try {
             const data = await fs_extra_1.default.readJson(this.configPath);
+            if (data.access_token) {
+                return data.access_token;
+            }
             return data.token || null;
         }
         catch {
             return null;
         }
     }
-    async clearToken() {
+    /**
+     * Return a valid access token, auto-refreshing if it expires in <5 minutes.
+     * Throws if the session is expired and refresh fails.
+     */
+    async getValidToken() {
+        const auth = await this.getAuth();
+        if (!auth) {
+            throw new Error("Not authenticated. Run 'kaven auth login' to authenticate.");
+        }
+        const expiresAt = new Date(auth.expires_at).getTime();
+        const now = Date.now();
+        const fiveMinutesMs = 5 * 60 * 1000;
+        const isExpiringSoon = expiresAt - now < fiveMinutesMs;
+        const isExpired = now >= expiresAt;
+        if (!isExpiringSoon) {
+            // Token is still valid and not expiring soon — return as-is
+            return auth.access_token;
+        }
+        // Attempt refresh
+        try {
+            // Lazy import to avoid circular dependency at module level
+            const { MarketplaceClient } = await Promise.resolve().then(() => __importStar(require("../infrastructure/MarketplaceClient")));
+            const client = new MarketplaceClient(this);
+            const refreshed = await client.refreshToken(auth.refresh_token);
+            // Update stored auth with new tokens
+            const newAuth = {
+                access_token: refreshed.access_token,
+                refresh_token: refreshed.refresh_token,
+                expires_at: refreshed.expires_at,
+                user: auth.user,
+            };
+            await this.saveTokens(newAuth);
+            return refreshed.access_token;
+        }
+        catch {
+            // Refresh failed — use existing token if still valid, else throw
+            if (!isExpired) {
+                console.warn("[kaven] Warning: Failed to refresh token. Using existing token.");
+                return auth.access_token;
+            }
+            throw new Error("Session expired. Run 'kaven auth login' to re-authenticate.");
+        }
+    }
+    /**
+     * Check if the user is authenticated. Never throws.
+     */
+    async isAuthenticated() {
+        try {
+            const token = await this.getToken();
+            return !!token;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Remove auth.json (logout)
+     */
+    async logout() {
         if (await fs_extra_1.default.pathExists(this.configPath)) {
             await fs_extra_1.default.remove(this.configPath);
         }
     }
-    async isAuthenticated() {
-        const token = await this.getToken();
-        return !!token;
+    /**
+     * Legacy alias for logout()
+     * @deprecated Use logout() instead
+     */
+    async clearToken() {
+        return this.logout();
     }
     /**
-     * Mock decoding of JWT for now.
-     * In a real implementation, we would use a library like 'jsonwebtoken'.
+     * Decode JWT and return user info from the access token payload.
      */
     async getUserInfo() {
-        const token = await this.getToken();
-        if (!token)
+        const auth = await this.getAuth();
+        if (!auth)
+            return null;
+        const payload = decodeJwtPayload(auth.access_token);
+        if (payload) {
+            return {
+                id: payload.sub,
+                email: payload.email,
+                name: payload.githubId,
+            };
+        }
+        // Fallback to stored user data if JWT decode fails
+        return {
+            id: auth.user.githubId,
+            email: auth.user.email,
+            name: undefined,
+        };
+    }
+    /**
+     * Get decoded JWT payload from stored access token.
+     */
+    async getDecodedToken() {
+        const auth = await this.getAuth();
+        if (!auth)
+            return null;
+        return decodeJwtPayload(auth.access_token);
+    }
+    /**
+     * Get the stored auth data along with human-readable expiry string.
+     */
+    async getWhoamiInfo() {
+        const auth = await this.getAuth();
+        if (!auth)
             return null;
-        // Simulate decoding (mocked)
         return {
-            id: "usr-mock-123",
-            email: "user@example.com",
-            name: "Kaven Explorador",
+            email: auth.user.email,
+            githubId: auth.user.githubId,
+            tier: auth.user.tier.charAt(0).toUpperCase() + auth.user.tier.slice(1),
+            sessionExpiry: formatExpiryRelative(auth.expires_at),
         };
     }
 }

package/dist/core/CacheManager.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheManager = void 0;
+exports.getCacheManager = getCacheManager;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+class CacheManager {
+    constructor(cacheDir, maxSizeBytes) {
+        this.cacheDir = cacheDir ?? path_1.default.join(os_1.default.homedir(), ".kaven", "cache");
+        this.maxSizeBytes = maxSizeBytes ?? 50 * 1024 * 1024; // 50MB
+        this.indexPath = path_1.default.join(this.cacheDir, "_index.json");
+    }
+    async ensureDir() {
+        await fs_extra_1.default.ensureDir(this.cacheDir);
+    }
+    keyToFileName(key) {
+        // Sanitize key to valid filename
+        return key.replace(/[^a-zA-Z0-9-_:.]/g, "_") + ".json";
+    }
+    async readIndex() {
+        try {
+            if (await fs_extra_1.default.pathExists(this.indexPath)) {
+                return (await fs_extra_1.default.readJson(this.indexPath));
+            }
+        }
+        catch {
+            // ignore
+        }
+        return {};
+    }
+    async writeIndex(index) {
+        await this.ensureDir();
+        await fs_extra_1.default.writeJson(this.indexPath, index, { spaces: 2 });
+    }
+    /** Get fresh data or null if expired. */
+    async get(key) {
+        const index = await this.readIndex();
+        const entry = index[key];
+        if (!entry)
+            return null;
+        if (Date.now() > entry.expiresAt)
+            return null;
+        try {
+            const filePath = path_1.default.join(this.cacheDir, entry.file);
+            const data = await fs_extra_1.default.readJson(filePath);
+            return data.data;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Get stale data (ignore TTL expiry) — for offline fallback. */
+    async getStale(key) {
+        const index = await this.readIndex();
+        const entry = index[key];
+        if (!entry)
+            return null;
+        try {
+            const filePath = path_1.default.join(this.cacheDir, entry.file);
+            const data = await fs_extra_1.default.readJson(filePath);
+            return data.data;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Set data with TTL. */
+    async set(key, data, ttlMs) {
+        await this.ensureDir();
+        const serialized = JSON.stringify(data);
+        const size = Buffer.byteLength(serialized, "utf8");
+        const now = Date.now();
+        const expiresAt = now + ttlMs;
+        const fileName = this.keyToFileName(key);
+        const filePath = path_1.default.join(this.cacheDir, fileName);
+        const entry = {
+            data,
+            expiresAt,
+            size,
+            createdAt: now,
+        };
+        await fs_extra_1.default.writeJson(filePath, entry, { spaces: 2 });
+        const index = await this.readIndex();
+        index[key] = {
+            file: fileName,
+            expiresAt,
+            size,
+            createdAt: now,
+        };
+        await this.writeIndex(index);
+        // Evict if over limit
+        await this.evict();
+    }
+    /** Evict oldest entries if total size exceeds the limit. */
+    async evict() {
+        const index = await this.readIndex();
+        const entries = Object.entries(index);
+        let totalSize = entries.reduce((sum, [, e]) => sum + e.size, 0);
+        if (totalSize <= this.maxSizeBytes)
+            return;
+        // Sort by oldest first
+        entries.sort(([, a], [, b]) => a.createdAt - b.createdAt);
+        const updatedIndex = { ...index };
+        for (const [key, entry] of entries) {
+            if (totalSize <= this.maxSizeBytes)
+                break;
+            try {
+                const filePath = path_1.default.join(this.cacheDir, entry.file);
+                await fs_extra_1.default.remove(filePath);
+                delete updatedIndex[key];
+                totalSize -= entry.size;
+            }
+            catch {
+                // ignore individual removal errors
+            }
+        }
+        await this.writeIndex(updatedIndex);
+    }
+    /** Get cache statistics. */
+    async stats() {
+        const index = await this.readIndex();
+        const entries = Object.values(index);
+        if (entries.length === 0) {
+            return { totalSize: 0, entries: 0 };
+        }
+        const totalSize = entries.reduce((sum, e) => sum + e.size, 0);
+        const timestamps = entries.map((e) => e.createdAt);
+        const oldest = new Date(Math.min(...timestamps));
+        const newest = new Date(Math.max(...timestamps));
+        return { totalSize, entries: entries.length, oldest, newest };
+    }
+    /** Clear all cache entries. */
+    async clear() {
+        if (await fs_extra_1.default.pathExists(this.cacheDir)) {
+            await fs_extra_1.default.remove(this.cacheDir);
+        }
+    }
+}
+exports.CacheManager = CacheManager;
+// Singleton instance
+let _cacheManager = null;
+function getCacheManager() {
+    if (!_cacheManager) {
+        _cacheManager = new CacheManager();
+    }
+    return _cacheManager;
+}