kaven-cli 0.1.0-alpha.1 → 0.3.5

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;
+}

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();