kaven-cli 0.1.0-alpha.1 → 0.3.5

package/dist/infrastructure/MarketplaceClient.js

@@ -1,73 +1,397 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MarketplaceClient = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const errors_1 = require("./errors");
+const DEFAULT_BASE_URL = "https://api.kaven.sh";
+const REQUEST_TIMEOUT_MS = 30000;
+const MAX_RETRIES = 3;
+const INITIAL_RETRY_DELAY_MS = 1000;
+function debug(message) {
+    if (process.env.KAVEN_DEBUG === "1") {
+        console.debug(`[kaven:debug] ${message}`);
+    }
+}
+/** Load the apiUrl from ~/.kaven/config.json if present. */
+async function loadConfigApiUrl() {
+    try {
+        const configPath = path_1.default.join(os_1.default.homedir(), ".kaven", "config.json");
+        if (await fs_extra_1.default.pathExists(configPath)) {
+            const config = await fs_extra_1.default.readJson(configPath);
+            if (typeof config.apiUrl === "string" && config.apiUrl) {
+                return config.apiUrl;
+            }
+        }
+    }
+    catch {
+        // Ignore config read errors
+    }
+    return null;
+}
+/** Resolve base URL from env → config file → default. */
+async function resolveBaseUrl() {
+    if (process.env.KAVEN_API_URL) {
+        return process.env.KAVEN_API_URL.replace(/\/$/, "");
+    }
+    const configUrl = await loadConfigApiUrl();
+    if (configUrl) {
+        return configUrl.replace(/\/$/, "");
+    }
+    return DEFAULT_BASE_URL;
+}
+/** Sleep helper for retry backoff. */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/** Determine if the error code / HTTP status is retryable. */
+function isRetryable(status) {
+    return status >= 500;
+}
 class MarketplaceClient {
-    constructor() {
-        this.mockModules = [
-            {
-                id: "auth-google",
-                name: "Google Auth",
-                description: "Integração completa com Google OAuth2 e suporte a multiplataforma.",
-                version: "1.2.0",
-                author: "Kaven Official",
-            },
-            {
-                id: "db-postgresql",
-                name: "PostgreSQL Adapter",
-                description: "Conexão otimizada para PostgreSQL com suporte a pooling e migrações.",
-                version: "2.0.1",
-                author: "Kaven Official",
-            },
-            {
-                id: "stripe-payments",
-                name: "Stripe Checkout",
-                description: "Lógica de pagamentos resiliente com suporte a webhooks e assinaturas.",
-                version: "1.0.5",
-                author: "Kaven Official",
-            },
-        ];
-    }
-    async listModules() {
-        // Simular latência de rede
-        await new Promise((resolve) => setTimeout(resolve, 800));
-        return this.mockModules;
+    constructor(authService) {
+        this.authService = authService ?? null;
+        this.baseURLPromise = resolveBaseUrl();
+    }
+    /** Resolve a relative API path to an absolute URL. */
+    async resolveUrl(path) {
+        const baseURL = await this.baseURLPromise;
+        return `${baseURL}${path}`;
+    }
+    // ──────────────────────────────────────────────────────────
+    // Core HTTP helpers
+    // ──────────────────────────────────────────────────────────
+    /**
+     * Make an HTTP request with retry logic and typed error mapping.
+     * `authenticated` controls whether Authorization header is attached.
+     */
+    async request(method, endpoint, options = {}) {
+        const baseURL = await this.baseURLPromise;
+        const url = `${baseURL}${endpoint}`;
+        const { body, authenticated = false } = options;
+        let lastError = null;
+        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+            if (attempt > 0) {
+                const delay = INITIAL_RETRY_DELAY_MS * Math.pow(2, attempt - 1);
+                debug(`Retry attempt ${attempt} for ${method} ${endpoint} (delay ${delay}ms)`);
+                await sleep(delay);
+            }
+            try {
+                const headers = {
+                    "Content-Type": "application/json",
+                    Accept: "application/json",
+                };
+                if (authenticated && this.authService) {
+                    const token = await this.authService.getValidToken();
+                    headers["Authorization"] = `Bearer ${token}`;
+                }
+                debug(`${method} ${url}`);
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+                let response;
+                try {
+                    response = await fetch(url, {
+                        method,
+                        headers,
+                        body: body !== undefined ? JSON.stringify(body) : undefined,
+                        signal: controller.signal,
+                    });
+                }
+                finally {
+                    clearTimeout(timeoutId);
+                }
+                debug(`Response: ${response.status} ${response.statusText}`);
+                // Map HTTP errors to typed exceptions
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => "");
+                    let errorMessage = errorText;
+                    try {
+                        const errorJson = JSON.parse(errorText);
+                        errorMessage = errorJson.message || errorJson.error || errorText;
+                    }
+                    catch {
+                        // keep raw text
+                    }
+                    switch (response.status) {
+                        case 401:
+                            throw new errors_1.AuthenticationError(errorMessage || "Authentication required");
+                        case 403: {
+                            let requiredTier = "pro";
+                            try {
+                                const parsed = JSON.parse(errorText);
+                                requiredTier = parsed.requiredTier || requiredTier;
+                            }
+                            catch {
+                                // ignore
+                            }
+                            throw new errors_1.LicenseRequiredError(requiredTier, errorMessage || "License required");
+                        }
+                        case 404:
+                            throw new errors_1.NotFoundError(errorMessage || "Resource not found");
+                        case 429: {
+                            const retryAfter = parseInt(response.headers.get("retry-after") ?? "60", 10);
+                            throw new errors_1.RateLimitError(isNaN(retryAfter) ? 60 : retryAfter);
+                        }
+                        default:
+                            if (isRetryable(response.status)) {
+                                lastError = new errors_1.ServerError(errorMessage || `Server error: ${response.status}`);
+                                continue; // retry
+                            }
+                            throw new errors_1.ServerError(errorMessage || `Server error: ${response.status}`);
+                    }
+                }
+                // Parse successful response
+                const contentType = response.headers.get("content-type") ?? "";
+                if (contentType.includes("application/json")) {
+                    return (await response.json());
+                }
+                // Return empty object for no-body responses (204, etc.)
+                return {};
+            }
+            catch (error) {
+                // Re-throw our typed errors without retrying on 4xx
+                if (error instanceof errors_1.AuthenticationError ||
+                    error instanceof errors_1.LicenseRequiredError ||
+                    error instanceof errors_1.NotFoundError ||
+                    error instanceof errors_1.RateLimitError) {
+                    throw error;
+                }
+                // Network / timeout errors
+                if (error instanceof TypeError ||
+                    (error instanceof Error && error.name === "AbortError")) {
+                    const networkError = new errors_1.NetworkError(error.name === "AbortError"
+                        ? "Request timed out after 30s"
+                        : `Network error: ${error.message}`);
+                    lastError = networkError;
+                    // Retry on network errors too
+                    if (attempt < MAX_RETRIES)
+                        continue;
+                    throw networkError;
+                }
+                // ServerError already stored in lastError, will retry
+                if (error instanceof errors_1.ServerError) {
+                    lastError = error;
+                    if (attempt < MAX_RETRIES)
+                        continue;
+                    throw error;
+                }
+                // Unknown error — don't retry
+                throw error;
+            }
+        }
+        // All retries exhausted
+        throw lastError ?? new errors_1.NetworkError("Request failed after retries");
+    }
+    // ──────────────────────────────────────────────────────────
+    // Auth endpoints (unauthenticated)
+    // ──────────────────────────────────────────────────────────
+    /**
+     * Step 1 of Device Code Flow: Request device code from marketplace.
+     */
+    async requestDeviceCode() {
+        return this.request("POST", "/auth/device-code", {
+            body: { client_id: "kaven-cli" },
+            authenticated: false,
+        });
+    }
+    /**
+     * Step 2 of Device Code Flow: Poll for access token.
+     */
+    async pollDeviceToken(deviceCode) {
+        try {
+            const baseURL = await this.baseURLPromise;
+            const url = `${baseURL}/auth/token`;
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+            let response;
+            try {
+                response = await fetch(url, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                        device_code: deviceCode,
+                        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+                    }),
+                    signal: controller.signal,
+                });
+            }
+            finally {
+                clearTimeout(timeoutId);
+            }
+            if (response.ok) {
+                const tokens = await response.json();
+                return { status: "success", tokens };
+            }
+            const errorData = await response.json().catch(() => ({}));
+            const errorCode = errorData.error ?? "unknown_error";
+            switch (errorCode) {
+                case "authorization_pending":
+                    return { status: "authorization_pending" };
+                case "slow_down":
+                    return { status: "slow_down" };
+                case "access_denied":
+                    return { status: "access_denied" };
+                case "expired_token":
+                    return { status: "expired_token" };
+                default:
+                    throw new Error(`Unexpected error: ${errorCode}`);
+            }
+        }
+        catch (error) {
+            const nodeError = error;
+            if (nodeError.code === "ECONNREFUSED" ||
+                nodeError.code === "ENOTFOUND") {
+                throw new errors_1.NetworkError("Network error. Check your connection and try again.");
+            }
+            throw error;
+        }
     }
+    /**
+     * Refresh access token using refresh token.
+     */
+    async refreshToken(refreshToken) {
+        return this.request("POST", "/auth/refresh", {
+            body: { refresh_token: refreshToken },
+            authenticated: false,
+        });
+    }
+    // ──────────────────────────────────────────────────────────
+    // Module endpoints (authenticated)
+    // ──────────────────────────────────────────────────────────
+    /**
+     * List available modules with optional filters.
+     */
+    async listModules(filters) {
+        const params = new URLSearchParams();
+        if (filters?.category)
+            params.set("category", filters.category);
+        if (filters?.tier)
+            params.set("tier", filters.tier);
+        if (filters?.q)
+            params.set("q", filters.q);
+        if (filters?.page)
+            params.set("page", String(filters.page));
+        if (filters?.pageSize)
+            params.set("pageSize", String(filters.pageSize));
+        const query = params.toString();
+        const endpoint = `/modules${query ? `?${query}` : ""}`;
+        return this.request("GET", endpoint);
+    }
+    /**
+     * Get a single module by slug.
+     */
+    async getModule(slug) {
+        return this.request("GET", `/modules/${slug}`);
+    }
+    /**
+     * Get a module's manifest for a specific version.
+     */
+    async getManifest(slug, version) {
+        return this.request("GET", `/modules/${slug}/versions/${version}/manifest`);
+    }
+    /**
+     * Create a download token for a module release.
+     */
+    async createDownloadToken(moduleSlug, version) {
+        return this.request("POST", "/download-tokens", {
+            body: { moduleSlug, version },
+            authenticated: true,
+        });
+    }
+    // ──────────────────────────────────────────────────────────
+    // License endpoints
+    // ──────────────────────────────────────────────────────────
+    /**
+     * Validate a license key against the required tier.
+     */
+    async validateLicense(licenseKey, requiredTier) {
+        const response = await this.request('POST', '/licenses/validate', {
+            body: { licenseKey, requiredTier },
+        });
+        return response;
+    }
+    /**
+     * Get full license status including expiry information.
+     */
+    async getLicenseStatus(licenseKey) {
+        return this.request('GET', `/licenses/status?key=${encodeURIComponent(licenseKey)}`);
+    }
+    // ──────────────────────────────────────────────────────────
+    // Legacy / backward-compat methods
+    // ──────────────────────────────────────────────────────────
+    /**
+     * @deprecated Use getManifest(slug, version) instead.
+     */
     async getModuleManifest(moduleId) {
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-        const module = this.mockModules.find((m) => m.id === moduleId);
-        if (!module)
-            return null;
-        // Gerar manifest mockado baseado no ID
-        return {
-            name: module.id,
-            version: module.version,
-            description: module.description,
-            author: module.author,
-            license: "Proprietary",
-            dependencies: {
-                npm: [],
-                peerModules: [],
-                kavenVersion: ">=0.1.0",
-            },
-            files: {
-                backend: [],
-                frontend: [],
-                database: [],
-            },
-            injections: [
-                {
-                    file: "kaven-setup.ts",
-                    anchor: "// KAVEN_INIT",
-                    code: `console.log("Module ${module.name} initialized!");`,
-                    moduleName: module.id,
-                },
-            ],
-            scripts: {
-                postInstall: null,
-                preRemove: null,
-            },
-            env: [],
-        };
+        try {
+            // Try to get latest manifest — for backward-compat we use "latest"
+            return await this.getManifest(moduleId, "latest");
+        }
+        catch (error) {
+            if (error instanceof errors_1.NotFoundError)
+                return null;
+            throw error;
+        }
+    }
+    /**
+     * Get release details for a specific module version.
+     * Returns checksum, signature, and publicKey for verification.
+     */
+    async getReleaseInfo(slug, version) {
+        return this.request("GET", `/modules/${slug}/versions/${version}`);
+    }
+    // ──────────────────────────────────────────────────────────
+    // Publish endpoints (authenticated)
+    // ──────────────────────────────────────────────────────────
+    /**
+     * Get a presigned S3 upload URL for a new module release.
+     */
+    async getUploadUrl(moduleSlug, version, size) {
+        return this.request("POST", "/releases/upload-url", {
+            body: { moduleSlug, version, size },
+            authenticated: true,
+        });
+    }
+    /**
+     * Create a release record after uploading the artifact.
+     */
+    async createRelease(data) {
+        return this.request("POST", "/releases", {
+            body: data,
+            authenticated: true,
+        });
+    }
+    // ──────────────────────────────────────────────────────────
+    // Checkout / upgrade endpoints (authenticated)
+    // ──────────────────────────────────────────────────────────
+    /**
+     * Create a Paddle checkout session for tier upgrade.
+     */
+    async createCheckoutSession(tier, licenseKey) {
+        return this.request("POST", "/checkout/session", {
+            body: { tier, licenseKey },
+            authenticated: true,
+        });
+    }
+    /**
+     * Poll the status of an ongoing Paddle checkout session.
+     */
+    async getCheckoutStatus(sessionId) {
+        return this.request("GET", `/checkout/session/${sessionId}/status`, { authenticated: true });
+    }
+    // ──────────────────────────────────────────────────────────
+    // Categories endpoint (authenticated)
+    // ──────────────────────────────────────────────────────────
+    /**
+     * Get all available module categories.
+     */
+    async getCategories() {
+        const result = await this.request("GET", "/modules/categories", { authenticated: true });
+        return result.categories;
     }
 }
 exports.MarketplaceClient = MarketplaceClient;

package/dist/infrastructure/errors.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignatureVerificationError = exports.NetworkError = exports.ServerError = exports.RateLimitError = exports.NotFoundError = exports.LicenseRequiredError = exports.AuthenticationError = exports.MarketplaceError = void 0;
+class MarketplaceError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "MarketplaceError";
+    }
+}
+exports.MarketplaceError = MarketplaceError;
+class AuthenticationError extends MarketplaceError {
+    constructor(message) {
+        super(message);
+        this.name = "AuthenticationError";
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+class LicenseRequiredError extends MarketplaceError {
+    constructor(requiredTier, message) {
+        super(message);
+        this.requiredTier = requiredTier;
+        this.name = "LicenseRequiredError";
+    }
+}
+exports.LicenseRequiredError = LicenseRequiredError;
+class NotFoundError extends MarketplaceError {
+    constructor(message) {
+        super(message);
+        this.name = "NotFoundError";
+    }
+}
+exports.NotFoundError = NotFoundError;
+class RateLimitError extends MarketplaceError {
+    constructor(retryAfter) {
+        super(`Rate limited. Try again in ${retryAfter}s`);
+        this.retryAfter = retryAfter;
+        this.name = "RateLimitError";
+    }
+}
+exports.RateLimitError = RateLimitError;
+class ServerError extends MarketplaceError {
+    constructor(message) {
+        super(message);
+        this.name = "ServerError";
+    }
+}
+exports.ServerError = ServerError;
+class NetworkError extends MarketplaceError {
+    constructor(message) {
+        super(message);
+        this.name = "NetworkError";
+    }
+}
+exports.NetworkError = NetworkError;
+class SignatureVerificationError extends MarketplaceError {
+    constructor(message) {
+        super(message);
+        this.name = "SignatureVerificationError";
+    }
+}
+exports.SignatureVerificationError = SignatureVerificationError;

package/dist/types/auth.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/marketplace.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kaven-cli",
-  "version": "0.1.0-alpha.1",
+  "version": "0.3.5",
   "description": "Kaven CLI - The official command line tool for Kaven",
   "main": "dist/index.js",
   "bin": {
@@ -12,7 +12,7 @@
   ],
   "scripts": {
     "build": "tsc",
-    "prepublishOnly": "pnpm run build && pnpm run quality",
+    "prepublishOnly": "pnpm run build",
     "lint": "eslint 'src/**/*.{ts,tsx}' --max-warnings 0",
     "lint:fix": "eslint 'src/**/*.{ts,tsx}' --fix",
     "test": "vitest run",
@@ -39,14 +39,22 @@
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "https://github.com/KavenCompany/kaven-cli"
+    "url": "https://github.com/kaven-co/kaven-cli"
   },
   "devDependencies": {
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/github": "^12.0.6",
+    "@semantic-release/npm": "^13.1.5",
+    "@semantic-release/release-notes-generator": "^14.1.0",
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^20.0.0",
+    "@types/tar": "^6.1.13",
     "@typescript-eslint/eslint-plugin": "^8.53.1",
     "@typescript-eslint/parser": "^8.53.1",
     "eslint": "^8.0.0",
+    "msw": "^2.12.10",
+    "semantic-release": "^25.0.3",
     "typescript": "^5.0.0",
     "vitest": "^1.0.0"
   },
@@ -54,11 +62,22 @@
     "node": ">=20"
   },
   "dependencies": {
+    "@inquirer/prompts": "^7.5.2",
     "chalk": "^5.6.2",
+    "cli-table3": "^0.6.5",
     "commander": "^14.0.2",
     "fs-extra": "^11.3.3",
     "glob": "^13.0.0",
+    "open": "^10.1.0",
     "ora": "^9.1.0",
+    "tar": "^7.5.9",
     "zod": "^4.3.6"
+  },
+  "pnpm": {
+    "overrides": {
+      "minimatch@<10.2.1": ">=10.2.1",
+      "@isaacs/brace-expansion@<=5.0.0": ">=5.0.1",
+      "esbuild@<=0.24.2": ">=0.25.0"
+    }
   }
-}
+}

package/dist/commands/modules/add.js

@@ -1,53 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addCommand = void 0;
-const commander_1 = require("commander");
-const path_1 = __importDefault(require("path"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const ModuleManager_1 = require("../../core/modules/ModuleManager");
-const ModuleInstaller_1 = require("../../core/modules/ModuleInstaller");
-const logger_1 = require("../../lib/logger");
-exports.addCommand = new commander_1.Command('add')
-    .description('Install a module')
-    .argument('<slug>', 'Module slug to install')
-    .action(async (slug) => {
-    try {
-        const projectRoot = process.cwd();
-        // Locate modules source: 
-        // In dev: ./modules
-        // In prod (installed): ../modules relative to dist
-        // For now, assume we run from CLI root or use logic to find 'modules' folder.
-        // Ideally CLI should be installed in a way that 'modules' folder is known.
-        // Fallback logic for finding modules source:
-        // 1. Env var KAVEN_MODULES_PATH
-        // 2. Local ./modules
-        // 3. Resolve relative to __dirname (dist) -> ../modules
-        let modulesSource = process.env.KAVEN_MODULES_PATH;
-        if (!modulesSource) {
-            if (await fs_extra_1.default.pathExists(path_1.default.resolve('modules'))) {
-                modulesSource = path_1.default.resolve('modules');
-            }
-            else {
-                modulesSource = path_1.default.resolve(__dirname, '../../modules');
-            }
-        }
-        if (!await fs_extra_1.default.pathExists(modulesSource)) {
-            logger_1.Logger.error(`Module source not found at ${modulesSource}`);
-            return;
-        }
-        const manifestPath = path_1.default.join(modulesSource, slug, 'module.json');
-        if (!await fs_extra_1.default.pathExists(manifestPath)) {
-            logger_1.Logger.error(`Module ${slug} not found in catalog.`);
-            return;
-        }
-        const manifest = await ModuleManager_1.ModuleManager.loadManifest(manifestPath);
-        await ModuleInstaller_1.ModuleInstaller.install(manifest, projectRoot, modulesSource);
-    }
-    catch (error) {
-        logger_1.Logger.error('Failed to add module', error);
-        process.exit(1);
-    }
-});