@rulebricks/cli 1.9.0

package/dist/lib/dockerHub.js

@@ -0,0 +1,128 @@
+/**
+ * Docker Hub API client for fetching image tags
+ *
+ * Uses the license key as a Docker PAT for authentication
+ * to access private Rulebricks images.
+ */
+const DOCKER_HUB_API = 'https://hub.docker.com/v2';
+const DOCKER_USERNAME = 'rulebricks';
+/**
+ * Formats the license key as a Docker PAT
+ */
+export function formatDockerPat(licenseKey) {
+    // If already formatted, return as-is
+    if (licenseKey.startsWith('dckr_pat_')) {
+        return licenseKey;
+    }
+    return `dckr_pat_${licenseKey}`;
+}
+/**
+ * Authenticates with Docker Hub using the license key as a PAT
+ *
+ * @param licenseKey - The Rulebricks license key (used as Docker PAT)
+ * @returns JWT token for subsequent API calls
+ */
+export async function authenticateDockerHub(licenseKey) {
+    const dockerPat = formatDockerPat(licenseKey);
+    const response = await fetch(`${DOCKER_HUB_API}/users/login`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            username: DOCKER_USERNAME,
+            password: dockerPat,
+        }),
+    });
+    if (!response.ok) {
+        if (response.status === 401) {
+            throw new Error('Invalid license key - Docker Hub authentication failed');
+        }
+        throw new Error(`Docker Hub authentication failed: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.token;
+}
+/**
+ * Fetches available tags for a Docker Hub repository
+ *
+ * @param repo - Repository name (e.g., "rulebricks/app")
+ * @param token - JWT token from authentication
+ * @param pageSize - Number of tags to fetch per page (max 100)
+ * @returns Array of image tags sorted by last updated (newest first)
+ */
+export async function fetchImageTags(repo, token, pageSize = 100) {
+    const allTags = [];
+    let url = `${DOCKER_HUB_API}/repositories/${repo}/tags?page_size=${pageSize}`;
+    while (url) {
+        const response = await fetch(url, {
+            headers: {
+                'Authorization': `Bearer ${token}`,
+            },
+        });
+        if (!response.ok) {
+            if (response.status === 404) {
+                throw new Error(`Repository not found: ${repo}`);
+            }
+            throw new Error(`Failed to fetch tags for ${repo}: ${response.status}`);
+        }
+        const data = await response.json();
+        for (const tag of data.results) {
+            // Skip non-semver tags like "latest", "dev", etc.
+            if (!isValidVersionTag(tag.name)) {
+                continue;
+            }
+            allTags.push({
+                name: tag.name,
+                lastUpdated: new Date(tag.last_updated),
+                digest: tag.digest,
+                fullSize: tag.full_size,
+            });
+        }
+        // Get next page if available (limit to reasonable number of versions)
+        url = data.next && allTags.length < 50 ? data.next : null;
+    }
+    // Sort by last updated, newest first
+    allTags.sort((a, b) => b.lastUpdated.getTime() - a.lastUpdated.getTime());
+    return allTags;
+}
+/**
+ * Checks if a tag looks like a valid semantic version
+ * Excludes "latest" and other non-numeric tags
+ */
+function isValidVersionTag(tag) {
+    // Exclude "latest" and similar non-versioned tags
+    if (tag === 'latest' || tag === 'dev' || tag === 'main' || tag === 'master') {
+        return false;
+    }
+    // Match patterns like "1.2.3", "v1.2.3", "1.2.3-beta.1"
+    const versionPattern = /^v?\d+\.\d+\.\d+(-[\w.]+)?$/;
+    return versionPattern.test(tag);
+}
+/**
+ * Fetches tags for both app and HPS repositories
+ *
+ * @param licenseKey - The Rulebricks license key
+ * @returns Object containing app and HPS tags
+ */
+export async function fetchAllImageTags(licenseKey) {
+    const token = await authenticateDockerHub(licenseKey);
+    const [appTags, hpsTags] = await Promise.all([
+        fetchImageTags('rulebricks/app', token),
+        fetchImageTags('rulebricks/hps', token),
+    ]);
+    return { appTags, hpsTags };
+}
+/**
+ * Normalizes a version string by removing leading 'v'
+ */
+export function normalizeVersion(version) {
+    return version.replace(/^v/, '');
+}
+/**
+ * Formats a version for display (ensures 'v' prefix)
+ */
+export function formatVersionDisplay(version) {
+    const normalized = normalizeVersion(version);
+    return `v${normalized}`;
+}

package/dist/lib/helm.d.ts

@@ -0,0 +1,53 @@
+import { ChartVersion } from "../types/index.js";
+/**
+ * Checks if Helm is installed
+ */
+export declare function isHelmInstalled(): Promise<boolean>;
+/**
+ * Gets the installed Helm version
+ */
+export declare function getHelmVersion(): Promise<string>;
+/**
+ * Fetches available chart versions from the OCI registry
+ */
+export declare function fetchChartVersions(): Promise<ChartVersion[]>;
+/**
+ * Gets the currently installed chart version for a deployment
+ */
+export declare function getInstalledVersion(releaseName: string, namespace: string): Promise<string | null>;
+/**
+ * Installs the Rulebricks Helm chart
+ */
+export declare function installChart(deploymentName: string, options: {
+    releaseName: string;
+    namespace: string;
+    version?: string;
+    wait?: boolean;
+    timeout?: string;
+    createNamespace?: boolean;
+}): Promise<void>;
+/**
+ * Upgrades the Rulebricks Helm chart
+ */
+export declare function upgradeChart(deploymentName: string, options: {
+    releaseName: string;
+    namespace: string;
+    version?: string;
+    wait?: boolean;
+    timeout?: string;
+}): Promise<void>;
+/**
+ * Uninstalls the Rulebricks Helm chart
+ */
+export declare function uninstallChart(releaseName: string, namespace: string, options?: {
+    wait?: boolean;
+    timeout?: string;
+}): Promise<void>;
+/**
+ * Performs a dry-run upgrade to preview changes
+ */
+export declare function dryRunUpgrade(deploymentName: string, options: {
+    releaseName: string;
+    namespace: string;
+    version?: string;
+}): Promise<string>;

package/dist/lib/helm.js

@@ -0,0 +1,209 @@
+import { execa } from "execa";
+import { HELM_CHART_OCI } from "../types/index.js";
+import { getHelmValuesPath } from "./config.js";
+/**
+ * Extracts meaningful error message from execa error
+ */
+function getErrorMessage(error) {
+    const execaError = error;
+    // Try stderr first, then stdout
+    const output = execaError.stderr || execaError.stdout || "";
+    if (output) {
+        // Get last 500 chars of output for the error message
+        const truncated = output.length > 500 ? "..." + output.slice(-500) : output;
+        return truncated;
+    }
+    return execaError.shortMessage || execaError.message || "Unknown error";
+}
+/**
+ * Checks if Helm is installed
+ */
+export async function isHelmInstalled() {
+    try {
+        await execa("helm", ["version", "--short"]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Gets the installed Helm version
+ */
+export async function getHelmVersion() {
+    const { stdout } = await execa("helm", ["version", "--short"]);
+    return stdout.trim();
+}
+/**
+ * Fetches available chart versions from the OCI registry
+ */
+export async function fetchChartVersions() {
+    try {
+        // Use helm show chart to get info about the latest version
+        const { stdout } = await execa("helm", ["show", "chart", HELM_CHART_OCI]);
+        // Parse the chart info
+        const lines = stdout.split("\n");
+        const versionLine = lines.find((l) => l.startsWith("version:"));
+        const appVersionLine = lines.find((l) => l.startsWith("appVersion:"));
+        const version = versionLine?.split(":")[1]?.trim() || "unknown";
+        const appVersion = appVersionLine?.split(":")[1]?.trim() || version;
+        // Return at least the current version
+        return [
+            {
+                version,
+                appVersion,
+                created: new Date().toISOString(),
+                digest: "",
+            },
+        ];
+    }
+    catch (error) {
+        // If we can't fetch, try to get from GitHub API
+        return fetchVersionsFromGitHub();
+    }
+}
+/**
+ * Fetches versions from GitHub releases API
+ */
+async function fetchVersionsFromGitHub() {
+    try {
+        const response = await fetch("https://api.github.com/repos/rulebricks/helm/releases");
+        if (!response.ok) {
+            throw new Error(`GitHub API returned ${response.status}`);
+        }
+        const releases = (await response.json());
+        return releases
+            .filter((r) => !r.prerelease)
+            .map((r) => ({
+            version: r.tag_name.replace(/^v/, ""),
+            appVersion: r.tag_name.replace(/^v/, ""),
+            created: r.published_at,
+            digest: "",
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Gets the currently installed chart version for a deployment
+ */
+export async function getInstalledVersion(releaseName, namespace) {
+    try {
+        const { stdout } = await execa("helm", ["list", "-n", namespace, "-f", `^${releaseName}$`, "-o", "json"], { timeout: 15000 }); // 15 second timeout
+        const releases = JSON.parse(stdout);
+        if (releases.length > 0) {
+            return (releases[0].app_version || releases[0].chart.split("-").pop() || null);
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Installs the Rulebricks Helm chart
+ */
+export async function installChart(deploymentName, options) {
+    const { releaseName, namespace, version, wait = true, timeout = "15m", createNamespace = true, } = options;
+    const valuesPath = getHelmValuesPath(deploymentName);
+    const args = [
+        "install",
+        releaseName,
+        HELM_CHART_OCI,
+        "--namespace",
+        namespace,
+        "--values",
+        valuesPath,
+    ];
+    if (version) {
+        args.push("--version", version);
+    }
+    if (createNamespace) {
+        args.push("--create-namespace");
+    }
+    if (wait) {
+        args.push("--wait");
+        args.push("--timeout", timeout);
+    }
+    try {
+        await execa("helm", args);
+    }
+    catch (error) {
+        throw new Error(`Helm install failed:\n${getErrorMessage(error)}`);
+    }
+}
+/**
+ * Upgrades the Rulebricks Helm chart
+ */
+export async function upgradeChart(deploymentName, options) {
+    const { releaseName, namespace, version, wait = true, timeout = "15m", } = options;
+    const valuesPath = getHelmValuesPath(deploymentName);
+    const args = [
+        "upgrade",
+        releaseName,
+        HELM_CHART_OCI,
+        "--namespace",
+        namespace,
+        "--values",
+        valuesPath,
+    ];
+    if (version) {
+        args.push("--version", version);
+    }
+    if (wait) {
+        args.push("--wait");
+        args.push("--timeout", timeout);
+    }
+    try {
+        await execa("helm", args);
+    }
+    catch (error) {
+        throw new Error(`Helm upgrade failed:\n${getErrorMessage(error)}`);
+    }
+}
+/**
+ * Uninstalls the Rulebricks Helm chart
+ */
+export async function uninstallChart(releaseName, namespace, options = {}) {
+    const { wait = false, timeout = "10m" } = options;
+    const args = ["uninstall", releaseName, "--namespace", namespace];
+    if (wait) {
+        args.push("--wait");
+        args.push("--timeout", timeout);
+    }
+    try {
+        // 60 second process timeout to prevent hanging
+        await execa("helm", args, { timeout: 60000 });
+    }
+    catch (error) {
+        const execaError = error;
+        // Ignore "release not found" errors and timeouts (we'll continue anyway)
+        const errorMsg = execaError.stderr || execaError.message || "";
+        if (!errorMsg.includes("not found") && !execaError.timedOut) {
+            throw new Error(`Helm uninstall failed:\n${getErrorMessage(error)}`);
+        }
+    }
+}
+/**
+ * Performs a dry-run upgrade to preview changes
+ */
+export async function dryRunUpgrade(deploymentName, options) {
+    const { releaseName, namespace, version } = options;
+    const valuesPath = getHelmValuesPath(deploymentName);
+    const args = [
+        "upgrade",
+        releaseName,
+        HELM_CHART_OCI,
+        "--namespace",
+        namespace,
+        "--values",
+        valuesPath,
+        "--dry-run",
+    ];
+    if (version) {
+        args.push("--version", version);
+    }
+    const { stdout } = await execa("helm", args);
+    return stdout;
+}

package/dist/lib/helmValues.d.ts

@@ -0,0 +1,17 @@
+import { DeploymentConfig } from "../types/index.js";
+interface GenerateOptions {
+    tlsEnabled?: boolean;
+}
+/**
+ * Generates Helm values from the deployment configuration
+ */
+export declare function generateHelmValues(config: DeploymentConfig, options?: GenerateOptions): Promise<void>;
+/**
+ * Updates existing Helm values to enable or disable TLS
+ */
+export declare function updateHelmValuesForTLS(deploymentName: string, tlsEnabled: boolean): Promise<void>;
+/**
+ * Updates existing Helm values with new configuration
+ */
+export declare function mergeHelmValues(existing: Record<string, unknown>, updates: Partial<Record<string, unknown>>): Record<string, unknown>;
+export {};