kaven-cli 0.4.0 → 0.4.1-alpha.0

package/dist/EnvManager-GQMEZ6NV.js

@@ -0,0 +1,158 @@
+import "./chunk-3RG5ZIWI.js";
+
+// src/core/EnvManager.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as readline from "readline";
+import chalk from "chalk";
+var EnvManager = class {
+  async injectEnvVars(moduleSlug, envVars, options) {
+    if (options.skipEnv || !envVars || envVars.length === 0) {
+      return { added: 0, skipped: 0 };
+    }
+    const envFilePath = path.join(options.projectDir, options.envFile ?? ".env");
+    const existingContent = this.readEnvFile(envFilePath);
+    const existingVars = this.parseEnvFile(existingContent);
+    const newVars = [];
+    let skipped = 0;
+    console.log(chalk.bold(`
+  Environment variables for '${moduleSlug}':
+`));
+    for (const envDef of envVars) {
+      if (existingVars.has(envDef.name)) {
+        console.log(chalk.dim(`  ${envDef.name} \u2014 already set, skipping`));
+        skipped++;
+        continue;
+      }
+      let value;
+      if (envDef.sensitive) {
+        value = await this.promptPassword(
+          `  ${envDef.name} (${envDef.description})${envDef.default ? " [****]" : ""}: `
+        );
+        if (!value && envDef.default) value = envDef.default;
+      } else {
+        const defaultHint = envDef.default ? ` [${envDef.default}]` : "";
+        value = await this.promptInput(
+          `  ${envDef.name} (${envDef.description})${defaultHint}: `,
+          envDef.default
+        );
+      }
+      if (envDef.required && !value) {
+        console.log(chalk.yellow(`  ${envDef.name} is required.`));
+        value = envDef.sensitive ? await this.promptPassword(`  ${envDef.name}: `) : await this.promptInput(`  ${envDef.name}: `);
+        if (!value) {
+          console.log(chalk.yellow(`  Skipping ${envDef.name} \u2014 set it manually in .env`));
+          skipped++;
+          continue;
+        }
+      }
+      newVars.push({ name: envDef.name, value });
+    }
+    if (newVars.length === 0) {
+      console.log(chalk.dim("  No new environment variables to add."));
+      return { added: 0, skipped };
+    }
+    const markerBlock = this.buildMarkerBlock(moduleSlug, newVars);
+    this.appendToEnvFile(envFilePath, existingContent, markerBlock);
+    console.log(
+      chalk.green(`
+  Added ${newVars.length} environment variable(s) to ${options.envFile ?? ".env"}`)
+    );
+    return { added: newVars.length, skipped };
+  }
+  removeEnvVars(moduleSlug, options) {
+    const envFiles = [".env", ".env.local", ".env.development", ".env.production"];
+    if (options.envFile) envFiles.unshift(options.envFile);
+    let totalRemoved = 0;
+    for (const envFile of envFiles) {
+      const envFilePath = path.join(options.projectDir, envFile);
+      if (!fs.existsSync(envFilePath)) continue;
+      const content = fs.readFileSync(envFilePath, "utf-8");
+      const beginMarker = `# [KAVEN_MODULE:${moduleSlug} BEGIN]`;
+      const endMarker = `# [KAVEN_MODULE:${moduleSlug} END]`;
+      const beginIdx = content.indexOf(beginMarker);
+      const endIdx = content.indexOf(endMarker);
+      if (beginIdx === -1 || endIdx === -1) continue;
+      const block = content.substring(beginIdx, endIdx + endMarker.length);
+      const varCount = block.split("\n").filter((l) => /^[A-Z_]+=/.test(l)).length;
+      const before = content.substring(0, beginIdx).replace(/\n+$/, "\n");
+      const after = content.substring(endIdx + endMarker.length + 1);
+      fs.writeFileSync(envFilePath, before + after);
+      totalRemoved += varCount;
+      if (varCount > 0) {
+        console.log(chalk.dim(`  Removed ${varCount} env var(s) from ${envFile}`));
+      }
+    }
+    return totalRemoved;
+  }
+  readEnvFile(filePath) {
+    try {
+      return fs.readFileSync(filePath, "utf-8");
+    } catch {
+      return "";
+    }
+  }
+  parseEnvFile(content) {
+    const vars = /* @__PURE__ */ new Map();
+    for (const line of content.split("\n")) {
+      const match = line.match(/^([A-Z_][A-Z0-9_]*)=(.*)$/);
+      if (match) vars.set(match[1], match[2]);
+    }
+    return vars;
+  }
+  buildMarkerBlock(moduleSlug, vars) {
+    return [
+      `# [KAVEN_MODULE:${moduleSlug} BEGIN]`,
+      ...vars.map((v) => `${v.name}=${v.value}`),
+      `# [KAVEN_MODULE:${moduleSlug} END]`
+    ].join("\n");
+  }
+  appendToEnvFile(filePath, existingContent, block) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const separator = existingContent.endsWith("\n") || existingContent === "" ? "\n" : "\n\n";
+    fs.writeFileSync(filePath, existingContent + separator + block + "\n");
+  }
+  promptInput(message, defaultValue) {
+    return new Promise((resolve) => {
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      rl.question(message, (answer) => {
+        rl.close();
+        resolve(answer || defaultValue || "");
+      });
+    });
+  }
+  promptPassword(message) {
+    return new Promise((resolve) => {
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      process.stdout.write(message);
+      process.stdin.setRawMode?.(true);
+      process.stdin.resume();
+      let password = "";
+      const handler = (key) => {
+        const char = key.toString();
+        if (char === "\r" || char === "\n") {
+          process.stdin.setRawMode?.(false);
+          process.stdin.pause();
+          process.stdin.removeListener("data", handler);
+          process.stdout.write("\n");
+          rl.close();
+          resolve(password);
+        } else if (char === "") {
+          process.exit();
+        } else if (char === "\x7F") {
+          password = password.slice(0, -1);
+          process.stdout.clearLine(0);
+          process.stdout.cursorTo(0);
+          process.stdout.write(message + "*".repeat(password.length));
+        } else {
+          password += char;
+          process.stdout.write("*");
+        }
+      };
+      process.stdin.on("data", handler);
+    });
+  }
+};
+export {
+  EnvManager
+};

package/dist/MarketplaceClient-IJGRQRC4.js

@@ -0,0 +1,7 @@
+import {
+  MarketplaceClient
+} from "./chunk-GHZX5OAA.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  MarketplaceClient
+};

package/dist/chunk-3RG5ZIWI.js

@@ -0,0 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};

package/dist/chunk-GHZX5OAA.js

@@ -0,0 +1,455 @@
+// 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

@@ -0,0 +1,20 @@
+"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);
+    });
+}