@jawkit.cc/cli 0.1.0

package/dist/chunk-V3HNAAHL.js

@@ -0,0 +1,1369 @@
+#!/usr/bin/env node
+
+// package.json
+var version = "0.1.0";
+var description = "CLI toolkit for installing AI coding assistant configurations";
+
+// src/lib/logger.ts
+import chalk from "chalk";
+import ora from "ora";
+var Logger = class {
+  options;
+  currentSpinner = null;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  info(message) {
+    if (this.options.quiet) return;
+    console.log(message);
+  }
+  success(message) {
+    if (this.options.quiet) return;
+    console.log(chalk.green("\u2713"), message);
+  }
+  warn(message) {
+    console.log(chalk.yellow("\u26A0"), message);
+  }
+  error(message) {
+    console.error(chalk.red("\u2716"), message);
+  }
+  debug(message) {
+    if (!this.options.verbose) return;
+    console.log(chalk.gray(`[debug] ${message}`));
+  }
+  newline() {
+    if (this.options.quiet) return;
+    console.log();
+  }
+  divider(char = "\u2500", length = 40) {
+    if (this.options.quiet) return;
+    console.log(chalk.gray(char.repeat(length)));
+  }
+  spinner(text) {
+    this.currentSpinner = ora({
+      text,
+      spinner: "dots"
+    });
+    return this.currentSpinner;
+  }
+  stopSpinner() {
+    if (this.currentSpinner) {
+      this.currentSpinner.stop();
+      this.currentSpinner = null;
+    }
+  }
+  progress(percentage, text) {
+    if (this.options.quiet) return;
+    const width = 30;
+    const filled = Math.round(percentage / 100 * width);
+    const empty = width - filled;
+    const bar = chalk.green("\u2588".repeat(filled)) + chalk.gray("\u2591".repeat(empty));
+    process.stdout.write(`\r${bar} ${percentage}%${text ? ` ${text}` : ""}`);
+    if (percentage >= 100) {
+      console.log();
+    }
+  }
+  table(data) {
+    if (this.options.quiet) return;
+    console.table(data);
+  }
+  json(data) {
+    console.log(JSON.stringify(data, null, 2));
+  }
+};
+var logger = new Logger();
+
+// src/lib/errors.ts
+import chalk2 from "chalk";
+var JawKitError = class extends Error {
+  suggestion;
+  cause;
+  constructor(message, options) {
+    super(message);
+    this.name = this.constructor.name;
+    this.cause = options?.cause;
+  }
+};
+var AuthError = class _AuthError extends JawKitError {
+  code = "AUTH_ERROR";
+  static notAuthenticated() {
+    const error = new _AuthError("No license key activated");
+    error.suggestion = "Run 'jawkit auth activate <license-key>' to activate your license";
+    return error;
+  }
+  static licenseExpired() {
+    const error = new _AuthError("License has expired");
+    error.suggestion = "Visit https://jawkit.cc/pro to renew your license";
+    return error;
+  }
+  static activationFailed(reason) {
+    const error = new _AuthError(`License activation failed${reason ? `: ${reason}` : ""}`);
+    error.suggestion = "Check your license key and try again";
+    return error;
+  }
+  static licenseRevoked() {
+    const error = new _AuthError("License has been revoked");
+    error.suggestion = "Contact support at support@jawkit.cc";
+    return error;
+  }
+  static licenseNotFound() {
+    const error = new _AuthError("License key not found");
+    error.suggestion = "Check your license key and try again";
+    return error;
+  }
+};
+var ContentError = class _ContentError extends JawKitError {
+  code = "CONTENT_ERROR";
+  static manifestNotFound() {
+    const error = new _ContentError("Content manifest not found");
+    error.suggestion = "Check your internet connection and try again";
+    return error;
+  }
+  static checksumMismatch(bundle) {
+    const error = new _ContentError(
+      `Bundle checksum verification failed: ${bundle}`
+    );
+    error.suggestion = "Try running the command again. The download may have been corrupted.";
+    return error;
+  }
+  static downloadFailed(bundle, status) {
+    const error = new _ContentError(
+      `Failed to download bundle: ${bundle}${status ? ` (HTTP ${status})` : ""}`
+    );
+    error.suggestion = "Check your internet connection and try again";
+    return error;
+  }
+  static extractionFailed(bundle) {
+    const error = new _ContentError(`Failed to extract bundle: ${bundle}`);
+    error.suggestion = "The bundle may be corrupted. Try running jawkit init again to re-download.";
+    return error;
+  }
+  static tierAccessDenied(tier) {
+    const error = new _ContentError(`Access denied for tier: ${tier}`);
+    error.suggestion = "Upgrade to Professional at https://jawkit.cc/pro";
+    return error;
+  }
+  static signedUrlFailed() {
+    const error = new _ContentError("Failed to get download authorization");
+    error.suggestion = "Check your license status with: jawkit auth status";
+    return error;
+  }
+};
+var AgentError = class _AgentError extends JawKitError {
+  code = "AGENT_ERROR";
+  static notFound(agentId) {
+    const error = new _AgentError(`Agent not found: ${agentId}`);
+    error.suggestion = "Run 'jawkit init --help' to see available agents";
+    return error;
+  }
+  static installFailed(agentId, reason) {
+    const error = new _AgentError(
+      `Failed to install ${agentId}${reason ? `: ${reason}` : ""}`
+    );
+    return error;
+  }
+  static alreadyInstalled(agentId, path5) {
+    const error = new _AgentError(`${agentId} is already installed at ${path5}`);
+    error.suggestion = "Run 'jawkit init' again to update (existing content will be backed up)";
+    return error;
+  }
+};
+var ConfigError = class _ConfigError extends JawKitError {
+  code = "CONFIG_ERROR";
+  static readFailed(path5) {
+    const error = new _ConfigError(`Failed to read config file: ${path5}`);
+    return error;
+  }
+  static writeFailed(path5) {
+    const error = new _ConfigError(`Failed to write config file: ${path5}`);
+    return error;
+  }
+};
+function handleError(error, logger2) {
+  if (error instanceof JawKitError) {
+    logger2.error(error.message);
+    if (error.suggestion) {
+      logger2.info(chalk2.dim(`  Suggestion: ${error.suggestion}`));
+    }
+    if (error.cause) {
+      logger2.debug(`Caused by: ${error.cause.message}`);
+    }
+  } else if (error instanceof Error) {
+    logger2.error(error.message);
+    if (error.stack) {
+      logger2.debug(error.stack);
+    }
+  } else {
+    logger2.error(String(error));
+  }
+}
+
+// src/lib/config.ts
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+var CONFIG_DIR = path.join(os.homedir(), ".jawkit");
+var CONFIG_FILE = "config.json";
+var ConfigService = class {
+  configDir;
+  configPath;
+  config = null;
+  constructor(configDir = CONFIG_DIR) {
+    this.configDir = configDir;
+    this.configPath = path.join(configDir, CONFIG_FILE);
+  }
+  async initialize() {
+    await fs.mkdir(this.configDir, { recursive: true });
+  }
+  async load() {
+    if (this.config) {
+      return this.config;
+    }
+    try {
+      const content = await fs.readFile(this.configPath, "utf-8");
+      this.config = JSON.parse(content);
+      return this.config;
+    } catch {
+      this.config = {};
+      return this.config;
+    }
+  }
+  async save() {
+    await this.initialize();
+    await fs.writeFile(
+      this.configPath,
+      JSON.stringify(this.config ?? {}, null, 2)
+    );
+  }
+  async get(key) {
+    const config = await this.load();
+    return config[key];
+  }
+  async set(key, value) {
+    await this.load();
+    this.config = { ...this.config, [key]: value };
+    await this.save();
+  }
+  async getInstallations() {
+    return await this.get("installations") ?? [];
+  }
+  async addInstallation(installation) {
+    const installations = await this.getInstallations();
+    const existingIndex = installations.findIndex(
+      (i) => i.path === installation.path && i.agent === installation.agent
+    );
+    if (existingIndex >= 0) {
+      installations[existingIndex] = installation;
+    } else {
+      installations.push(installation);
+    }
+    await this.set("installations", installations);
+  }
+  async updateInstallation(installPath, updates) {
+    const installations = await this.getInstallations();
+    const index = installations.findIndex((i) => i.path === installPath);
+    if (index >= 0) {
+      installations[index] = { ...installations[index], ...updates };
+      await this.set("installations", installations);
+    }
+  }
+  getConfigDir() {
+    return this.configDir;
+  }
+};
+
+// src/auth/types.ts
+function getTierDisplayName(tier) {
+  switch (tier) {
+    case "free":
+      return "Free";
+    case "professional":
+      return "Professional ($99)";
+    default:
+      return "Unknown";
+  }
+}
+
+// src/auth/auth.service.ts
+import { ofetch } from "ofetch";
+
+// src/auth/license-storage.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+import os2 from "os";
+var STORAGE_DIR = path2.join(os2.homedir(), ".jawkit");
+var LICENSE_FILE = "license.json";
+var LicenseStorage = class {
+  getFilePath() {
+    return path2.join(STORAGE_DIR, LICENSE_FILE);
+  }
+  /**
+   * Store license data
+   */
+  async store(license) {
+    await fs2.mkdir(STORAGE_DIR, { recursive: true });
+    const filePath = this.getFilePath();
+    await fs2.writeFile(filePath, JSON.stringify(license, null, 2), {
+      mode: 384
+    });
+  }
+  /**
+   * Retrieve stored license
+   */
+  async retrieve() {
+    try {
+      const filePath = this.getFilePath();
+      const data = await fs2.readFile(filePath, "utf-8");
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Clear stored license
+   */
+  async clear() {
+    try {
+      const filePath = this.getFilePath();
+      await fs2.unlink(filePath);
+    } catch {
+    }
+  }
+  /**
+   * Check if license is stored
+   */
+  async hasLicense() {
+    const license = await this.retrieve();
+    return license !== null;
+  }
+};
+
+// src/auth/auth.service.ts
+var API_URL = process.env.JAWKIT_API_URL || "https://api.jawkit.cc";
+var AuthService = class {
+  licenseStorage;
+  constructor() {
+    this.licenseStorage = new LicenseStorage();
+  }
+  /**
+   * Activate a license key
+   * Validates against server and stores locally
+   */
+  async activate(licenseKey) {
+    if (!licenseKey.startsWith("JAWKIT_")) {
+      return {
+        success: false,
+        user: null,
+        error: "Invalid license key format. License keys start with JAWKIT_"
+      };
+    }
+    try {
+      const response = await ofetch(
+        `${API_URL}/license/validate`,
+        {
+          method: "POST",
+          body: { licenseKey }
+        }
+      );
+      if (!response.valid) {
+        return {
+          success: false,
+          user: null,
+          error: "License key validation failed"
+        };
+      }
+      const storedLicense = {
+        licenseKey,
+        email: response.email,
+        tier: response.tier,
+        tierExpiresAt: response.tierExpiresAt,
+        validatedAt: Date.now()
+      };
+      await this.licenseStorage.store(storedLicense);
+      return {
+        success: true,
+        user: {
+          email: response.email,
+          tier: response.tier,
+          tierExpiresAt: response.tierExpiresAt
+        }
+      };
+    } catch (error) {
+      if (error instanceof Error && "statusCode" in error) {
+        const statusCode = error.statusCode;
+        if (statusCode === 404) {
+          return {
+            success: false,
+            user: null,
+            error: "License key not found"
+          };
+        }
+        if (statusCode === 403) {
+          return {
+            success: false,
+            user: null,
+            error: "License has been revoked"
+          };
+        }
+      }
+      return {
+        success: false,
+        user: null,
+        error: error instanceof Error ? error.message : "Failed to validate license"
+      };
+    }
+  }
+  /**
+   * Deactivate (remove) stored license
+   */
+  async deactivate() {
+    await this.licenseStorage.clear();
+  }
+  /**
+   * Check if user has a valid license stored
+   */
+  async isAuthenticated() {
+    const license = await this.licenseStorage.retrieve();
+    if (!license) {
+      return false;
+    }
+    if (license.tierExpiresAt) {
+      const expiresAt = new Date(license.tierExpiresAt);
+      if (expiresAt < /* @__PURE__ */ new Date()) {
+        return true;
+      }
+    }
+    return true;
+  }
+  /**
+   * Get current user profile from stored license
+   */
+  async getCurrentUser() {
+    const license = await this.licenseStorage.retrieve();
+    if (!license) {
+      return null;
+    }
+    let effectiveTier = license.tier;
+    if (license.tierExpiresAt) {
+      const expiresAt = new Date(license.tierExpiresAt);
+      if (expiresAt < /* @__PURE__ */ new Date()) {
+        effectiveTier = "free";
+      }
+    }
+    return {
+      email: license.email,
+      tier: effectiveTier,
+      tierExpiresAt: license.tierExpiresAt
+    };
+  }
+  /**
+   * Get user's tier level
+   * Returns 'free' if no license or expired
+   */
+  async getUserTier() {
+    const user = await this.getCurrentUser();
+    return user?.tier ?? "free";
+  }
+  /**
+   * Get stored license key for API requests
+   */
+  async getLicenseKey() {
+    const license = await this.licenseStorage.retrieve();
+    return license?.licenseKey ?? null;
+  }
+  /**
+   * Redeem an invitation code
+   * Calls API to exchange invite code for license key, then activates it
+   */
+  async redeem(inviteCode, email) {
+    if (!inviteCode.startsWith("JAWKIT_INV_")) {
+      return {
+        success: false,
+        user: null,
+        error: "Invalid invitation code format. Invitation codes start with JAWKIT_INV_"
+      };
+    }
+    try {
+      const response = await ofetch(`${API_URL}/invitation/redeem`, {
+        method: "POST",
+        body: { inviteCode, email }
+      });
+      if (!response.success || !response.licenseKey) {
+        return {
+          success: false,
+          user: null,
+          error: "Failed to redeem invitation"
+        };
+      }
+      const storedLicense = {
+        licenseKey: response.licenseKey,
+        email: response.email,
+        tier: response.tier,
+        tierExpiresAt: response.tierExpiresAt,
+        validatedAt: Date.now()
+      };
+      await this.licenseStorage.store(storedLicense);
+      return {
+        success: true,
+        user: {
+          email: response.email,
+          tier: response.tier,
+          tierExpiresAt: response.tierExpiresAt
+        }
+      };
+    } catch (error) {
+      if (error instanceof Error && "data" in error) {
+        const data = error.data;
+        if (data?.error) {
+          return {
+            success: false,
+            user: null,
+            error: data.error
+          };
+        }
+      }
+      return {
+        success: false,
+        user: null,
+        error: error instanceof Error ? error.message : "Failed to redeem invitation"
+      };
+    }
+  }
+  /**
+   * Re-validate stored license against server
+   * Useful for refreshing tier status
+   */
+  async revalidate() {
+    const license = await this.licenseStorage.retrieve();
+    if (!license) {
+      return {
+        success: false,
+        user: null,
+        error: "No license key stored"
+      };
+    }
+    return this.activate(license.licenseKey);
+  }
+};
+var authServiceInstance = null;
+function getAuthService() {
+  if (!authServiceInstance) {
+    authServiceInstance = new AuthService();
+  }
+  return authServiceInstance;
+}
+
+// src/content/content.service.ts
+import fs6 from "fs/promises";
+
+// src/content/remote-provider.ts
+import { ofetch as ofetch2, FetchError } from "ofetch";
+import { createWriteStream } from "fs";
+import { pipeline } from "stream/promises";
+import { Readable } from "stream";
+var WORKER_URL = process.env.JAWKIT_WORKER_URL || "https://api.jawkit.cc";
+var R2_PUBLIC_URL = process.env.R2_PUBLIC_URL || "https://content.jawkit.cc";
+var RemoteProvider = class {
+  r2BaseUrl;
+  workerUrl;
+  constructor(r2BaseUrl, workerUrl) {
+    this.r2BaseUrl = r2BaseUrl || R2_PUBLIC_URL;
+    this.workerUrl = workerUrl || WORKER_URL;
+  }
+  /**
+   * Fetch content manifest from R2
+   * @param version - 'latest' or specific version (e.g., '1.0.0')
+   */
+  async fetchManifest(version2 = "latest") {
+    const url = version2 === "latest" ? `${this.r2BaseUrl}/manifests/latest.json` : `${this.r2BaseUrl}/manifests/${version2}.json`;
+    try {
+      const response = await ofetch2(url, {
+        timeout: 1e4,
+        retry: 2
+      });
+      return response;
+    } catch (error) {
+      if (error instanceof FetchError) {
+        if (error.status === 404) {
+          throw ContentError.manifestNotFound();
+        }
+        throw ContentError.downloadFailed("manifest", error.status);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get bundle download URL
+   * - Free tier: Direct public R2 URL
+   * - Premium tiers: Signed URL via Cloudflare Worker
+   */
+  async getBundleUrl(agentId, version2, tier, licenseKey) {
+    if (tier === "free") {
+      return `${this.r2BaseUrl}/bundles/${agentId}/${version2}/free.tar.gz`;
+    }
+    if (!licenseKey) {
+      throw ContentError.tierAccessDenied(tier);
+    }
+    try {
+      const response = await ofetch2(
+        `${this.workerUrl}/get-download-url`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `License ${licenseKey}`,
+            "Content-Type": "application/json"
+          },
+          body: {
+            agent: agentId,
+            version: version2,
+            tier
+          },
+          timeout: 1e4
+        }
+      );
+      return response.url;
+    } catch (error) {
+      if (error instanceof FetchError) {
+        if (error.status === 401) {
+          throw ContentError.tierAccessDenied(tier);
+        }
+        if (error.status === 403) {
+          throw ContentError.tierAccessDenied(tier);
+        }
+        throw ContentError.signedUrlFailed();
+      }
+      throw error;
+    }
+  }
+  /**
+   * Download file to disk with progress callback and retry logic
+   */
+  async downloadToFile(url, destPath, _expectedSize, onProgress, maxRetries = 3) {
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        const response = await fetch(url);
+        if (!response.ok) {
+          throw ContentError.downloadFailed(destPath, response.status);
+        }
+        if (!response.body) {
+          throw ContentError.downloadFailed(destPath);
+        }
+        const reader = response.body.getReader();
+        const writer = createWriteStream(destPath);
+        let downloaded = 0;
+        const readable = new Readable({
+          async read() {
+            try {
+              const { done, value } = await reader.read();
+              if (done) {
+                this.push(null);
+              } else {
+                downloaded += value.length;
+                onProgress?.(downloaded);
+                this.push(value);
+              }
+            } catch (error) {
+              this.destroy(error instanceof Error ? error : new Error(String(error)));
+            }
+          }
+        });
+        await pipeline(readable, writer);
+        return;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (error instanceof ContentError) {
+          throw error;
+        }
+        if (attempt < maxRetries) {
+          const delay = Math.pow(2, attempt - 1) * 1e3;
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      }
+    }
+    throw lastError || ContentError.downloadFailed(destPath);
+  }
+  /**
+   * Check if a bundle exists on the remote server
+   */
+  async checkBundleExists(agentId, version2, tier) {
+    const url = `${this.r2BaseUrl}/bundles/${agentId}/${version2}/${tier}.tar.gz`;
+    try {
+      const response = await fetch(url, { method: "HEAD" });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get the R2 base URL
+   */
+  getR2BaseUrl() {
+    return this.r2BaseUrl;
+  }
+  /**
+   * Get the Worker URL
+   */
+  getWorkerUrl() {
+    return this.workerUrl;
+  }
+};
+var remoteProviderInstance = null;
+function getRemoteProvider() {
+  if (!remoteProviderInstance) {
+    remoteProviderInstance = new RemoteProvider();
+  }
+  return remoteProviderInstance;
+}
+
+// src/content/cache-manager.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+import os3 from "os";
+var DEFAULT_CACHE_DIR = path3.join(os3.homedir(), ".jawkit", "cache");
+var MANIFEST_FILE = "manifest.json";
+var BUNDLES_DIR = "bundles";
+var TEMP_DIR = "temp";
+var CacheManager = class {
+  cacheDir;
+  initialized = false;
+  constructor(cacheDir = DEFAULT_CACHE_DIR) {
+    this.cacheDir = cacheDir;
+  }
+  /**
+   * Initialize cache directories
+   */
+  async initialize() {
+    if (this.initialized) return;
+    await fs3.mkdir(this.cacheDir, { recursive: true });
+    await fs3.mkdir(path3.join(this.cacheDir, BUNDLES_DIR), { recursive: true });
+    await fs3.mkdir(path3.join(this.cacheDir, TEMP_DIR), { recursive: true });
+    this.initialized = true;
+  }
+  // Manifest caching
+  /**
+   * Save manifest to cache
+   */
+  async saveManifest(manifest) {
+    await this.initialize();
+    const filePath = path3.join(this.cacheDir, MANIFEST_FILE);
+    await fs3.writeFile(filePath, JSON.stringify(manifest, null, 2), "utf-8");
+  }
+  /**
+   * Get cached manifest
+   */
+  async getManifest() {
+    try {
+      const filePath = path3.join(this.cacheDir, MANIFEST_FILE);
+      const content = await fs3.readFile(filePath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  // Bundle caching
+  /**
+   * Save downloaded bundle to cache
+   * @param agentId - Agent identifier
+   * @param version - Content version
+   * @param tier - Tier level
+   * @param sourcePath - Path to the downloaded file (will be moved)
+   * @returns Path to cached bundle
+   */
+  async saveBundle(agentId, version2, tier, sourcePath) {
+    await this.initialize();
+    const bundleDir = path3.join(this.cacheDir, BUNDLES_DIR, agentId, version2);
+    await fs3.mkdir(bundleDir, { recursive: true });
+    const destPath = path3.join(bundleDir, `${tier}.tar.gz`);
+    await fs3.rename(sourcePath, destPath);
+    return destPath;
+  }
+  /**
+   * Get cached bundle path if exists
+   */
+  async getBundle(agentId, version2, tier) {
+    const bundlePath = path3.join(
+      this.cacheDir,
+      BUNDLES_DIR,
+      agentId,
+      version2,
+      `${tier}.tar.gz`
+    );
+    try {
+      await fs3.access(bundlePath);
+      return bundlePath;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Check if a bundle exists in cache
+   */
+  async hasBundle(agentId, version2, tier) {
+    const bundlePath = await this.getBundle(agentId, version2, tier);
+    return bundlePath !== null;
+  }
+  // Temp file management
+  /**
+   * Get a path in the temp directory for downloads
+   */
+  async getTempPath(filename) {
+    await this.initialize();
+    return path3.join(this.cacheDir, TEMP_DIR, filename);
+  }
+  /**
+   * Clean temporary files
+   */
+  async cleanTemp() {
+    const tempDir = path3.join(this.cacheDir, TEMP_DIR);
+    try {
+      await fs3.rm(tempDir, { recursive: true, force: true });
+      await fs3.mkdir(tempDir, { recursive: true });
+    } catch {
+    }
+  }
+  // Cache management
+  /**
+   * Clear all cached data
+   */
+  async clearCache() {
+    await fs3.rm(this.cacheDir, { recursive: true, force: true });
+    this.initialized = false;
+    await this.initialize();
+  }
+  /**
+   * Clear cache for a specific agent
+   */
+  async clearAgentCache(agentId) {
+    const agentDir = path3.join(this.cacheDir, BUNDLES_DIR, agentId);
+    try {
+      await fs3.rm(agentDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  /**
+   * Clear old versions, keeping only the specified version
+   */
+  async clearOldVersions(agentId, keepVersion) {
+    const agentDir = path3.join(this.cacheDir, BUNDLES_DIR, agentId);
+    let removedCount = 0;
+    try {
+      const versions = await fs3.readdir(agentDir);
+      for (const version2 of versions) {
+        if (version2 !== keepVersion) {
+          await fs3.rm(path3.join(agentDir, version2), { recursive: true, force: true });
+          removedCount++;
+        }
+      }
+    } catch {
+    }
+    return removedCount;
+  }
+  /**
+   * Get total cache size in bytes
+   */
+  async getCacheSize() {
+    let totalSize = 0;
+    async function calculateSize(dirPath) {
+      try {
+        const entries = await fs3.readdir(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+          const entryPath = path3.join(dirPath, entry.name);
+          if (entry.isDirectory()) {
+            await calculateSize(entryPath);
+          } else {
+            const stats = await fs3.stat(entryPath);
+            totalSize += stats.size;
+          }
+        }
+      } catch {
+      }
+    }
+    await calculateSize(this.cacheDir);
+    return totalSize;
+  }
+  /**
+   * Get detailed cache information
+   */
+  async getCacheInfo() {
+    const size = await this.getCacheSize();
+    const bundlesDir = path3.join(this.cacheDir, BUNDLES_DIR);
+    const agents = {};
+    try {
+      const agentDirs = await fs3.readdir(bundlesDir);
+      for (const agent of agentDirs) {
+        const agentPath = path3.join(bundlesDir, agent);
+        try {
+          const stat = await fs3.stat(agentPath);
+          if (stat.isDirectory()) {
+            const versions = await fs3.readdir(agentPath);
+            const versionDirs = [];
+            for (const v of versions) {
+              const vPath = path3.join(agentPath, v);
+              try {
+                const vStat = await fs3.stat(vPath);
+                if (vStat.isDirectory()) {
+                  versionDirs.push(v);
+                }
+              } catch {
+              }
+            }
+            agents[agent] = versionDirs;
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return { size, agents };
+  }
+  /**
+   * Get the cache directory path
+   */
+  getCacheDir() {
+    return this.cacheDir;
+  }
+};
+var cacheManagerInstance = null;
+function getCacheManager() {
+  if (!cacheManagerInstance) {
+    cacheManagerInstance = new CacheManager();
+  }
+  return cacheManagerInstance;
+}
+
+// src/content/bundled-content.ts
+import fs4 from "fs";
+import path4 from "path";
+import { fileURLToPath } from "url";
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path4.dirname(__filename2);
+var BUNDLED_DIR = path4.join(__dirname2, "../../content");
+var BundledContent = class {
+  bundledDir;
+  constructor(bundledDir = BUNDLED_DIR) {
+    this.bundledDir = bundledDir;
+  }
+  /**
+   * Check if bundled content exists
+   */
+  isAvailable() {
+    try {
+      const manifestPath = path4.join(this.bundledDir, "manifest.json");
+      fs4.accessSync(manifestPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get bundled manifest (free tier info)
+   */
+  getManifest() {
+    const manifestPath = path4.join(this.bundledDir, "manifest.json");
+    const content = fs4.readFileSync(manifestPath, "utf-8");
+    return JSON.parse(content);
+  }
+  /**
+   * Get bundled manifest or null if not available
+   */
+  getManifestOrNull() {
+    try {
+      return this.getManifest();
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get path to bundled tar.gz file for an agent
+   * Only 'free' tier is bundled
+   */
+  getBundlePath(agentId, tier = "free") {
+    const bundlePath = path4.join(this.bundledDir, agentId, `${tier}.tar.gz`);
+    try {
+      fs4.accessSync(bundlePath);
+      return bundlePath;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Check if bundled content exists for an agent
+   */
+  hasBundle(agentId) {
+    return this.getBundlePath(agentId) !== null;
+  }
+  /**
+   * List available bundled agents
+   */
+  listAgents() {
+    try {
+      const entries = fs4.readdirSync(this.bundledDir, { withFileTypes: true });
+      return entries.filter((e) => e.isDirectory()).filter((e) => {
+        const bundlePath = path4.join(this.bundledDir, e.name, "free.tar.gz");
+        try {
+          fs4.accessSync(bundlePath);
+          return true;
+        } catch {
+          return false;
+        }
+      }).map((e) => e.name);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Get the version of bundled content
+   */
+  getVersion() {
+    const manifest = this.getManifestOrNull();
+    return manifest?.version ?? null;
+  }
+  /**
+   * Get the bundled directory path (for debugging)
+   */
+  getBundledDir() {
+    return this.bundledDir;
+  }
+};
+var bundledContentInstance = null;
+function getBundledContent() {
+  if (!bundledContentInstance) {
+    bundledContentInstance = new BundledContent();
+  }
+  return bundledContentInstance;
+}
+
+// src/content/extractor.ts
+import { createGunzip } from "zlib";
+import { extract as tarExtract } from "tar";
+import { createReadStream } from "fs";
+import fs5 from "fs/promises";
+import crypto from "crypto";
+async function extractBundle(bundlePath, targetDir, onProgress) {
+  const filesExtracted = [];
+  let totalSize = 0;
+  const errors = [];
+  try {
+    await fs5.mkdir(targetDir, { recursive: true });
+    await new Promise((resolve, reject) => {
+      const readStream = createReadStream(bundlePath);
+      const gunzip = createGunzip();
+      const extractor = tarExtract({
+        cwd: targetDir,
+        strip: 0,
+        // Don't strip leading path components
+        filter: (entryPath) => {
+          return !entryPath.endsWith("manifest.json");
+        },
+        onentry: (entry) => {
+          filesExtracted.push(entry.path);
+          totalSize += entry.size || 0;
+          onProgress?.({
+            phase: "extracting",
+            totalBytes: totalSize,
+            processedBytes: totalSize,
+            percentage: 100,
+            // We don't know total until done
+            currentFile: entry.path
+          });
+        }
+      });
+      readStream.on("error", reject).pipe(gunzip).on("error", reject).pipe(extractor).on("error", reject).on("finish", resolve);
+    });
+    return {
+      success: true,
+      filesExtracted,
+      totalSize,
+      errors
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown extraction error";
+    errors.push(errorMessage);
+    return {
+      success: false,
+      filesExtracted,
+      totalSize,
+      errors
+    };
+  }
+}
+async function verifyChecksum(filePath, expectedChecksum) {
+  const hash = crypto.createHash("sha256");
+  const stream = createReadStream(filePath);
+  for await (const chunk of stream) {
+    hash.update(chunk);
+  }
+  const actualChecksum = `sha256:${hash.digest("hex")}`;
+  return actualChecksum === expectedChecksum;
+}
+
+// src/content/content.service.ts
+var ContentService = class {
+  remote;
+  cache;
+  bundled;
+  constructor(remote, cache, bundled) {
+    this.remote = remote || getRemoteProvider();
+    this.cache = cache || getCacheManager();
+    this.bundled = bundled || getBundledContent();
+  }
+  /**
+   * Get the content manifest
+   * Falls back: remote → cache → bundled
+   */
+  async getManifest(version2 = "latest") {
+    try {
+      const manifest = await this.remote.fetchManifest(version2);
+      await this.cache.saveManifest(manifest);
+      return manifest;
+    } catch {
+      const cached = await this.cache.getManifest();
+      if (cached) {
+        return cached;
+      }
+      const bundledManifest = this.bundled.getManifestOrNull();
+      if (bundledManifest) {
+        return bundledManifest;
+      }
+      throw ContentError.manifestNotFound();
+    }
+  }
+  /**
+   * Get bundle info for a user's tier
+   */
+  async getBundleInfo(agentId, tier) {
+    const manifest = await this.getManifest();
+    const agentManifest = manifest.agents[agentId];
+    if (!agentManifest) {
+      throw new ContentError(`Agent not found in manifest: ${agentId}`);
+    }
+    const bundleInfo = agentManifest.bundles[tier] || agentManifest.bundles["free"];
+    if (!bundleInfo) {
+      throw new ContentError(`No bundle available for agent: ${agentId}`);
+    }
+    return bundleInfo;
+  }
+  /**
+   * Download and extract a content bundle
+   */
+  async downloadAndExtractBundle(agentId, tier, targetDir, onProgress) {
+    const manifest = await this.getManifest();
+    const agentManifest = manifest.agents[agentId];
+    if (!agentManifest) {
+      throw new ContentError(`Agent not found: ${agentId}`);
+    }
+    const effectiveTier = agentManifest.bundles[tier] ? tier : "free";
+    const bundleInfo = agentManifest.bundles[effectiveTier];
+    if (!bundleInfo) {
+      throw new ContentError(`No bundle available for agent: ${agentId}`);
+    }
+    const version2 = agentManifest.version;
+    const cachedBundle = await this.cache.getBundle(agentId, version2, effectiveTier);
+    let bundlePath;
+    if (cachedBundle && await verifyChecksum(cachedBundle, bundleInfo.checksum)) {
+      bundlePath = cachedBundle;
+    } else {
+      bundlePath = await this.downloadBundle(
+        agentId,
+        version2,
+        effectiveTier,
+        bundleInfo,
+        onProgress
+      );
+    }
+    const result = await extractBundle(bundlePath, targetDir, onProgress);
+    await this.cache.clearOldVersions(agentId, version2);
+    return {
+      ...result,
+      version: version2
+    };
+  }
+  /**
+   * Download a bundle to cache
+   */
+  async downloadBundle(agentId, version2, tier, bundleInfo, onProgress) {
+    let licenseKey = null;
+    if (tier !== "free") {
+      const authService = getAuthService();
+      licenseKey = await authService.getLicenseKey();
+    }
+    const downloadUrl = await this.remote.getBundleUrl(
+      agentId,
+      version2,
+      tier,
+      licenseKey
+    );
+    const tempPath = await this.cache.getTempPath(`${agentId}-${version2}-${tier}.tar.gz`);
+    await this.remote.downloadToFile(downloadUrl, tempPath, bundleInfo.size, (downloaded) => {
+      onProgress?.({
+        phase: "downloading",
+        totalBytes: bundleInfo.size,
+        processedBytes: downloaded,
+        percentage: Math.round(downloaded / bundleInfo.size * 100)
+      });
+    });
+    if (!await verifyChecksum(tempPath, bundleInfo.checksum)) {
+      await fs6.unlink(tempPath);
+      throw ContentError.checksumMismatch(bundleInfo.filename);
+    }
+    const cachePath = await this.cache.saveBundle(agentId, version2, tier, tempPath);
+    return cachePath;
+  }
+  /**
+   * Check for content updates
+   * Returns null if no update available or if check fails
+   * Use verbose logging to see failure details
+   */
+  async checkForUpdates(agentId, currentVersion, verbose = false) {
+    try {
+      const manifest = await this.remote.fetchManifest("latest");
+      const agentManifest = manifest.agents[agentId];
+      if (!agentManifest) {
+        if (verbose) {
+          console.error(`Update check: agent "${agentId}" not found in manifest`);
+        }
+        return null;
+      }
+      if (this.isNewerVersion(agentManifest.version, currentVersion)) {
+        const professional = agentManifest.bundles["professional"];
+        const free = agentManifest.bundles["free"];
+        const displayBundle = professional || free;
+        if (!displayBundle) {
+          return null;
+        }
+        return {
+          currentVersion,
+          latestVersion: agentManifest.version,
+          changelog: manifest.changelog,
+          publishedAt: new Date(manifest.publishedAt),
+          bundleSize: displayBundle.size,
+          fileCount: displayBundle.fileCount
+        };
+      }
+      return null;
+    } catch (error) {
+      if (verbose) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Update check failed: ${message}`);
+      }
+      return null;
+    }
+  }
+  /**
+   * Extract bundled fallback content (free tier only)
+   */
+  async extractFallbackContent(agentId, targetDir, onProgress) {
+    const bundlePath = this.bundled.getBundlePath(agentId);
+    if (!bundlePath) {
+      throw new ContentError("No bundled fallback content available");
+    }
+    const result = await extractBundle(bundlePath, targetDir, onProgress);
+    const manifest = this.bundled.getManifestOrNull();
+    return {
+      ...result,
+      version: manifest?.version || "bundled"
+    };
+  }
+  /**
+   * Check if bundled fallback is available for an agent
+   */
+  hasFallbackContent(agentId) {
+    return this.bundled.hasBundle(agentId);
+  }
+  /**
+   * Compare semantic versions
+   */
+  isNewerVersion(latest, current) {
+    const latestParts = latest.split(".").map(Number);
+    const currentParts = current.split(".").map(Number);
+    for (let i = 0; i < 3; i++) {
+      const l = latestParts[i] || 0;
+      const c = currentParts[i] || 0;
+      if (l > c) return true;
+      if (l < c) return false;
+    }
+    return false;
+  }
+};
+var contentServiceInstance = null;
+function getContentService() {
+  if (!contentServiceInstance) {
+    contentServiceInstance = new ContentService();
+  }
+  return contentServiceInstance;
+}
+
+// src/services/cli-version.ts
+import { ofetch as ofetch3 } from "ofetch";
+var NPM_REGISTRY = "https://registry.npmjs.org";
+var PACKAGE_NAME = "@jawkit/cli";
+function getCliVersion() {
+  return version;
+}
+async function checkCliUpdate() {
+  try {
+    const response = await ofetch3(
+      `${NPM_REGISTRY}/${encodeURIComponent(PACKAGE_NAME)}`,
+      {
+        timeout: 5e3,
+        headers: {
+          Accept: "application/json"
+        }
+      }
+    );
+    return response["dist-tags"].latest;
+  } catch {
+    return null;
+  }
+}
+function isNewerVersion(latest, current) {
+  const latestParts = latest.split(".").map(Number);
+  const currentParts = current.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const l = latestParts[i] || 0;
+    const c = currentParts[i] || 0;
+    if (l > c) return true;
+    if (l < c) return false;
+  }
+  return false;
+}
+
+// src/services/content-version.ts
+async function checkContentUpdates(currentVersions) {
+  const contentService = new ContentService();
+  const updates = {};
+  try {
+    const manifest = await contentService.getManifest("latest");
+    for (const [agentId, agentManifest] of Object.entries(manifest.agents)) {
+      const current = currentVersions[agentId];
+      const latest = agentManifest.version;
+      if (!current || isNewerVersion(latest, current)) {
+        updates[agentId] = latest;
+      }
+    }
+  } catch {
+  }
+  return updates;
+}
+
+export {
+  version,
+  description,
+  Logger,
+  JawKitError,
+  AuthError,
+  ContentError,
+  AgentError,
+  ConfigError,
+  handleError,
+  ConfigService,
+  getTierDisplayName,
+  getAuthService,
+  getContentService,
+  getCliVersion,
+  checkCliUpdate,
+  isNewerVersion,
+  checkContentUpdates
+};
+//# sourceMappingURL=chunk-V3HNAAHL.js.map