kaven-cli 0.4.1-alpha.0 → 0.6.0

package/dist/chunk-GHZX5OAA.js

@@ -1,455 +0,0 @@
-// src/infrastructure/MarketplaceClient.ts
-import fs from "fs-extra";
-import path from "path";
-import os from "os";
-
-// src/infrastructure/errors.ts
-var MarketplaceError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "MarketplaceError";
-  }
-};
-var AuthenticationError = class extends MarketplaceError {
-  constructor(message) {
-    super(message);
-    this.name = "AuthenticationError";
-  }
-};
-var LicenseRequiredError = class extends MarketplaceError {
-  constructor(requiredTier, message) {
-    super(message);
-    this.requiredTier = requiredTier;
-    this.name = "LicenseRequiredError";
-  }
-};
-var NotFoundError = class extends MarketplaceError {
-  constructor(message) {
-    super(message);
-    this.name = "NotFoundError";
-  }
-};
-var RateLimitError = class extends MarketplaceError {
-  constructor(retryAfter) {
-    super(`Rate limited. Try again in ${retryAfter}s`);
-    this.retryAfter = retryAfter;
-    this.name = "RateLimitError";
-  }
-};
-var ServerError = class extends MarketplaceError {
-  constructor(message) {
-    super(message);
-    this.name = "ServerError";
-  }
-};
-var NetworkError = class extends MarketplaceError {
-  constructor(message) {
-    super(message);
-    this.name = "NetworkError";
-  }
-};
-var SignatureVerificationError = class extends MarketplaceError {
-  constructor(message) {
-    super(message);
-    this.name = "SignatureVerificationError";
-  }
-};
-
-// src/infrastructure/MarketplaceClient.ts
-var DEFAULT_BASE_URL = "https://api.kaven.sh";
-var REQUEST_TIMEOUT_MS = 3e4;
-var MAX_RETRIES = 3;
-var INITIAL_RETRY_DELAY_MS = 1e3;
-function debug(message) {
-  if (process.env.KAVEN_DEBUG === "1") {
-    console.debug(`[kaven:debug] ${message}`);
-  }
-}
-async function loadConfigApiUrl() {
-  try {
-    const configPath = path.join(os.homedir(), ".kaven", "config.json");
-    if (await fs.pathExists(configPath)) {
-      const config = await fs.readJson(configPath);
-      if (typeof config.apiUrl === "string" && config.apiUrl) {
-        return config.apiUrl;
-      }
-    }
-  } catch {
-  }
-  return null;
-}
-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;
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function isRetryable(status) {
-  return status >= 500;
-}
-var MarketplaceClient = class {
-  baseURLPromise;
-  authService;
-  constructor(authService) {
-    this.authService = authService ?? null;
-    this.baseURLPromise = resolveBaseUrl();
-  }
-  /** Resolve a relative API path to an absolute URL. */
-  async resolveUrl(path2) {
-    const baseURL = await this.baseURLPromise;
-    return `${baseURL}${path2}`;
-  }
-  // ──────────────────────────────────────────────────────────
-  // 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 !== void 0 ? JSON.stringify(body) : void 0,
-            signal: controller.signal
-          });
-        } finally {
-          clearTimeout(timeoutId);
-        }
-        debug(`Response: ${response.status} ${response.statusText}`);
-        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 {
-          }
-          switch (response.status) {
-            case 401:
-              throw new AuthenticationError(
-                errorMessage || "Authentication required"
-              );
-            case 403: {
-              let requiredTier = "pro";
-              try {
-                const parsed = JSON.parse(errorText);
-                requiredTier = parsed.requiredTier || requiredTier;
-              } catch {
-              }
-              throw new LicenseRequiredError(
-                requiredTier,
-                errorMessage || "License required"
-              );
-            }
-            case 404:
-              throw new NotFoundError(errorMessage || "Resource not found");
-            case 429: {
-              const retryAfter = parseInt(
-                response.headers.get("retry-after") ?? "60",
-                10
-              );
-              throw new RateLimitError(isNaN(retryAfter) ? 60 : retryAfter);
-            }
-            default:
-              if (isRetryable(response.status)) {
-                lastError = new ServerError(
-                  errorMessage || `Server error: ${response.status}`
-                );
-                continue;
-              }
-              throw new ServerError(
-                errorMessage || `Server error: ${response.status}`
-              );
-          }
-        }
-        const contentType = response.headers.get("content-type") ?? "";
-        if (contentType.includes("application/json")) {
-          return await response.json();
-        }
-        return {};
-      } catch (error) {
-        if (error instanceof AuthenticationError || error instanceof LicenseRequiredError || error instanceof NotFoundError || error instanceof RateLimitError) {
-          throw error;
-        }
-        if (error instanceof TypeError || error instanceof Error && error.name === "AbortError") {
-          const networkError = new NetworkError(
-            error.name === "AbortError" ? "Request timed out after 30s" : `Network error: ${error.message}`
-          );
-          lastError = networkError;
-          if (attempt < MAX_RETRIES) continue;
-          throw networkError;
-        }
-        if (error instanceof ServerError) {
-          lastError = error;
-          if (attempt < MAX_RETRIES) continue;
-          throw error;
-        }
-        throw error;
-      }
-    }
-    throw lastError ?? new 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 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) {
-    try {
-      return await this.getManifest(moduleId, "latest");
-    } catch (error) {
-      if (error instanceof 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;
-  }
-};
-
-export {
-  AuthenticationError,
-  LicenseRequiredError,
-  NotFoundError,
-  NetworkError,
-  SignatureVerificationError,
-  MarketplaceClient
-};

package/dist/commands/aiox/index.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerAioxCommand = registerAioxCommand;
-const aiox_bootstrap_1 = require("../init/aiox-bootstrap");
-/**
- * Registers the AIOX integration commands
- */
-function registerAioxCommand(program) {
-    const aiox = program
-        .command("aiox")
-        .description("AIOX integration utilities");
-    aiox
-        .command("bootstrap")
-        .description("Run AIOX environment bootstrap in current project")
-        .option("--skip-aiox", "Skip AIOX logic (for testing)")
-        .action(async (options) => {
-        const projectDir = process.cwd();
-        await (0, aiox_bootstrap_1.runEnvironmentBootstrap)(projectDir, options);
-    });
-}

package/dist/commands/auth/login.js

@@ -1,122 +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.authLogin = authLogin;
-const chalk_1 = __importDefault(require("chalk"));
-const ora_1 = __importDefault(require("ora"));
-const open_1 = __importDefault(require("open"));
-const AuthService_1 = require("../../core/AuthService");
-const MarketplaceClient_1 = require("../../infrastructure/MarketplaceClient");
-const TelemetryBuffer_1 = require("../../infrastructure/TelemetryBuffer");
-/**
- * Sleep helper for polling delays
- */
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-/**
- * Poll for access token with exponential backoff
- */
-async function pollForToken(client, deviceCode, expiresIn, initialInterval, spinner) {
-    const deadline = Date.now() + expiresIn * 1000;
-    const backoffIntervals = [5, 10, 15, 20]; // seconds - exponential backoff
-    let backoffIndex = 0;
-    let interval = initialInterval;
-    while (Date.now() < deadline) {
-        // Update countdown spinner
-        const remaining = Math.ceil((deadline - Date.now()) / 1000);
-        const mm = Math.floor(remaining / 60);
-        const ss = String(remaining % 60).padStart(2, '0');
-        spinner.text = `Waiting for authorization... (expires in ${mm}:${ss})`;
-        // Wait for next poll
-        await sleep(interval * 1000);
-        try {
-            const result = await client.pollDeviceToken(deviceCode);
-            // Success - return tokens
-            if (result.status === 'success' && result.tokens) {
-                return result.tokens;
-            }
-            // Handle different status codes
-            switch (result.status) {
-                case 'slow_down':
-                    // Increase interval by 5s as requested by server
-                    interval += 5;
-                    break;
-                case 'access_denied':
-                    throw new Error('Authorization denied by user. Try again with \'kaven auth login\'.');
-                case 'expired_token':
-                    throw new Error('Device code expired. Run \'kaven auth login\' again.');
-                case 'authorization_pending':
-                    // Continue polling - apply exponential backoff
-                    if (backoffIndex < backoffIntervals.length - 1) {
-                        backoffIndex++;
-                        interval = backoffIntervals[backoffIndex];
-                    }
-                    break;
-            }
-        }
-        catch (error) {
-            // Re-throw our custom errors
-            if (error.message.includes('denied') ||
-                error.message.includes('expired')) {
-                throw error;
-            }
-            // Network errors
-            const nodeError = error;
-            if (nodeError.code === 'ECONNREFUSED' || nodeError.code === 'ENOTFOUND') {
-                throw new Error('Network error. Check your connection and try again.');
-            }
-            // Unknown error
-            throw error;
-        }
-    }
-    // Timeout - device code expired
-    throw new Error('Device code expired. Run \'kaven auth login\' again.');
-}
-/**
- * Main login command - OAuth 2.0 Device Authorization Grant (RFC 8628)
- */
-async function authLogin() {
-    const telemetry = TelemetryBuffer_1.TelemetryBuffer.getInstance();
-    const startTime = Date.now();
-    telemetry.capture("cli.auth.login.start");
-    const client = new MarketplaceClient_1.MarketplaceClient();
-    const authService = new AuthService_1.AuthService();
-    console.log(chalk_1.default.blue("🔐 Starting authentication flow...\n"));
-    const spinner = (0, ora_1.default)("Requesting device code from marketplace...").start();
-    try {
-        // Step 1: Request device code
-        const { device_code, user_code, verification_uri, expires_in, interval } = await client.requestDeviceCode();
-        spinner.stop();
-        // Step 2: Display code and open browser
-        console.log(chalk_1.default.yellow("To complete login, follow these steps:\n"));
-        console.log(chalk_1.default.bold(`  Your verification code: ${chalk_1.default.cyan(user_code)}\n`));
-        try {
-            await (0, open_1.default)(verification_uri);
-            console.log(chalk_1.default.dim("  ✓ Browser opened automatically"));
-        }
-        catch {
-            console.log(chalk_1.default.yellow(`  Open this URL in your browser:`));
-            console.log(chalk_1.default.underline(`  ${verification_uri}\n`));
-        }
-        // Step 3: Poll for token with exponential backoff
-        const pollSpinner = (0, ora_1.default)('Waiting for authorization...').start();
-        const tokens = await pollForToken(client, device_code, expires_in, interval, pollSpinner);
-        // Step 4: Store tokens securely
-        await authService.saveTokens(tokens);
-        pollSpinner.succeed(chalk_1.default.green(`Logged in as ${chalk_1.default.bold(tokens.user.email)}`));
-        console.log(chalk_1.default.dim(`  Tier: ${tokens.user.tier}`));
-        console.log(chalk_1.default.gray("\n  Your credentials were saved securely in ~/.kaven/auth.json\n"));
-        telemetry.capture("cli.auth.login.success", { tier: tokens.user.tier }, Date.now() - startTime);
-        await telemetry.flush();
-    }
-    catch (error) {
-        telemetry.capture("cli.auth.login.error", { error: error.message }, Date.now() - startTime);
-        await telemetry.flush();
-        spinner.fail(chalk_1.default.red("Authentication failed"));
-        console.error(chalk_1.default.red(`\n  Error: ${error.message}\n`));
-        process.exit(1);
-    }
-}

package/dist/commands/auth/logout.js

@@ -1,23 +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.authLogout = authLogout;
-const chalk_1 = __importDefault(require("chalk"));
-const AuthService_1 = require("../../core/AuthService");
-async function authLogout() {
-    const authService = new AuthService_1.AuthService();
-    try {
-        if (!(await authService.isAuthenticated())) {
-            console.log(chalk_1.default.yellow("You are not authenticated."));
-            return;
-        }
-        await authService.logout();
-        console.log(chalk_1.default.green("Logged out successfully."));
-    }
-    catch {
-        console.error(chalk_1.default.red("Error during logout."));
-        process.exit(1);
-    }
-}

package/dist/commands/auth/whoami.js

@@ -1,36 +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.authWhoami = authWhoami;
-const chalk_1 = __importDefault(require("chalk"));
-const AuthService_1 = require("../../core/AuthService");
-const TelemetryBuffer_1 = require("../../infrastructure/TelemetryBuffer");
-async function authWhoami() {
-    const telemetry = TelemetryBuffer_1.TelemetryBuffer.getInstance();
-    telemetry.capture("cli.auth.whoami.start");
-    const authService = new AuthService_1.AuthService();
-    try {
-        const info = await authService.getWhoamiInfo();
-        if (!info) {
-            console.log(chalk_1.default.yellow("You are not authenticated."));
-            console.log(chalk_1.default.gray("Use 'kaven auth login' to sign in."));
-            telemetry.capture("cli.auth.whoami.not_authenticated");
-            await telemetry.flush();
-            return;
-        }
-        telemetry.capture("cli.auth.whoami.authenticated");
-        console.log();
-        console.log(`  ${chalk_1.default.bold("Email:")}    ${info.email}`);
-        console.log(`  ${chalk_1.default.bold("GitHub:")}   ${info.githubId}`);
-        console.log(`  ${chalk_1.default.bold("Tier:")}     ${info.tier}`);
-        console.log(`  ${chalk_1.default.bold("Session:")}  ${info.sessionExpiry}`);
-        console.log();
-    }
-    catch {
-        console.error(chalk_1.default.red("Error checking authentication status."));
-        process.exit(1);
-    }
-    await telemetry.flush();
-}