@rulebricks/cli 1.9.0

package/dist/lib/config.d.ts

@@ -0,0 +1,91 @@
+import { DeploymentConfig, DeploymentState, ProfileConfig } from "../types/index.js";
+/**
+ * Ensures the base directories exist
+ */
+export declare function ensureDirectories(): Promise<void>;
+/**
+ * Gets the deployment directory path
+ */
+export declare function getDeploymentDir(name: string): string;
+/**
+ * Lists all deployments
+ */
+export declare function listDeployments(): Promise<string[]>;
+/**
+ * Checks if a deployment exists
+ */
+export declare function deploymentExists(name: string): Promise<boolean>;
+/**
+ * Saves a deployment configuration
+ */
+export declare function saveDeploymentConfig(config: DeploymentConfig): Promise<void>;
+/**
+ * Loads a deployment configuration
+ */
+export declare function loadDeploymentConfig(name: string): Promise<DeploymentConfig>;
+/**
+ * Clones a deployment configuration to a new name
+ * Only copies config.yaml with the new name - state and terraform are not copied
+ */
+export declare function cloneDeploymentConfig(sourceName: string, targetName: string): Promise<DeploymentConfig>;
+/**
+ * Saves the deployment state
+ */
+export declare function saveDeploymentState(name: string, state: DeploymentState): Promise<void>;
+/**
+ * Loads the deployment state
+ */
+export declare function loadDeploymentState(name: string): Promise<DeploymentState | null>;
+/**
+ * Saves the generated Helm values
+ */
+export declare function saveHelmValues(name: string, values: Record<string, unknown>): Promise<string>;
+/**
+ * Loads the Helm values
+ */
+export declare function loadHelmValues(name: string): Promise<Record<string, unknown> | null>;
+/**
+ * Gets the Helm values file path
+ */
+export declare function getHelmValuesPath(name: string): string;
+/**
+ * Saves Terraform variables
+ */
+export declare function saveTerraformVars(name: string, vars: Record<string, unknown>): Promise<string>;
+/**
+ * Gets the Terraform working directory
+ */
+export declare function getTerraformDir(name: string): string;
+/**
+ * Deletes a deployment and all its files
+ */
+export declare function deleteDeployment(name: string): Promise<void>;
+/**
+ * Updates the deployment state status
+ */
+export declare function updateDeploymentStatus(name: string, status: DeploymentState["status"], updates?: Partial<DeploymentState>): Promise<void>;
+/**
+ * Extracts the domain suffix from a full domain.
+ * e.g., "app.example.com" -> ".example.com"
+ * e.g., "sub.app.example.com" -> ".app.example.com"
+ */
+export declare function extractDomainSuffix(domain: string): string | undefined;
+/**
+ * Loads the user profile from ~/.rulebricks/profile.yaml
+ * Returns null if the profile doesn't exist or is invalid
+ */
+export declare function loadProfile(): Promise<ProfileConfig | null>;
+/**
+ * Saves the user profile to ~/.rulebricks/profile.yaml
+ */
+export declare function saveProfile(profile: ProfileConfig): Promise<void>;
+/**
+ * Extracts profile-worthy values from a deployment configuration.
+ * These are values that are likely to be reused across deployments.
+ */
+export declare function extractProfileFromConfig(config: DeploymentConfig): ProfileConfig;
+/**
+ * Merges a new profile with an existing one, preferring new non-undefined values.
+ * This allows incremental updates without losing existing preferences.
+ */
+export declare function updateProfile(newValues: ProfileConfig): Promise<void>;

package/dist/lib/config.js

@@ -0,0 +1,278 @@
+import { promises as fs } from "fs";
+import path from "path";
+import os from "os";
+import yaml from "yaml";
+import { DeploymentConfigSchema, ProfileConfigSchema, } from "../types/index.js";
+const RULEBRICKS_DIR = path.join(os.homedir(), ".rulebricks");
+const DEPLOYMENTS_DIR = path.join(RULEBRICKS_DIR, "deployments");
+const PROFILE_FILE = "profile.yaml";
+/**
+ * Ensures the base directories exist
+ */
+export async function ensureDirectories() {
+    await fs.mkdir(DEPLOYMENTS_DIR, { recursive: true });
+}
+/**
+ * Gets the deployment directory path
+ */
+export function getDeploymentDir(name) {
+    return path.join(DEPLOYMENTS_DIR, name);
+}
+/**
+ * Lists all deployments
+ */
+export async function listDeployments() {
+    await ensureDirectories();
+    try {
+        const entries = await fs.readdir(DEPLOYMENTS_DIR, { withFileTypes: true });
+        return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Checks if a deployment exists
+ */
+export async function deploymentExists(name) {
+    const dir = getDeploymentDir(name);
+    try {
+        await fs.access(dir);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Saves a deployment configuration
+ */
+export async function saveDeploymentConfig(config) {
+    const dir = getDeploymentDir(config.name);
+    await fs.mkdir(dir, { recursive: true });
+    const configPath = path.join(dir, "config.yaml");
+    await fs.writeFile(configPath, yaml.stringify(config), "utf-8");
+}
+/**
+ * Loads a deployment configuration
+ */
+export async function loadDeploymentConfig(name) {
+    const configPath = path.join(getDeploymentDir(name), "config.yaml");
+    const content = await fs.readFile(configPath, "utf-8");
+    const parsed = yaml.parse(content);
+    return DeploymentConfigSchema.parse(parsed);
+}
+/**
+ * Clones a deployment configuration to a new name
+ * Only copies config.yaml with the new name - state and terraform are not copied
+ */
+export async function cloneDeploymentConfig(sourceName, targetName) {
+    const sourceConfig = await loadDeploymentConfig(sourceName);
+    const clonedConfig = {
+        ...sourceConfig,
+        name: targetName,
+    };
+    await saveDeploymentConfig(clonedConfig);
+    return clonedConfig;
+}
+/**
+ * Saves the deployment state
+ */
+export async function saveDeploymentState(name, state) {
+    const dir = getDeploymentDir(name);
+    await fs.mkdir(dir, { recursive: true });
+    const statePath = path.join(dir, "state.yaml");
+    await fs.writeFile(statePath, yaml.stringify(state), "utf-8");
+}
+/**
+ * Loads the deployment state
+ */
+export async function loadDeploymentState(name) {
+    const statePath = path.join(getDeploymentDir(name), "state.yaml");
+    try {
+        const content = await fs.readFile(statePath, "utf-8");
+        return yaml.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Saves the generated Helm values
+ */
+export async function saveHelmValues(name, values) {
+    const dir = getDeploymentDir(name);
+    await fs.mkdir(dir, { recursive: true });
+    const valuesPath = path.join(dir, "values.yaml");
+    await fs.writeFile(valuesPath, yaml.stringify(values), "utf-8");
+    return valuesPath;
+}
+/**
+ * Loads the Helm values
+ */
+export async function loadHelmValues(name) {
+    const valuesPath = path.join(getDeploymentDir(name), "values.yaml");
+    try {
+        const content = await fs.readFile(valuesPath, "utf-8");
+        return yaml.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Gets the Helm values file path
+ */
+export function getHelmValuesPath(name) {
+    return path.join(getDeploymentDir(name), "values.yaml");
+}
+/**
+ * Saves Terraform variables
+ */
+export async function saveTerraformVars(name, vars) {
+    const dir = path.join(getDeploymentDir(name), "terraform");
+    await fs.mkdir(dir, { recursive: true });
+    // Convert to HCL-compatible format
+    let content = "";
+    for (const [key, value] of Object.entries(vars)) {
+        if (typeof value === "string") {
+            content += `${key} = "${value}"\n`;
+        }
+        else if (typeof value === "number" || typeof value === "boolean") {
+            content += `${key} = ${value}\n`;
+        }
+        else {
+            content += `${key} = ${JSON.stringify(value)}\n`;
+        }
+    }
+    const varsPath = path.join(dir, "terraform.tfvars");
+    await fs.writeFile(varsPath, content, "utf-8");
+    return varsPath;
+}
+/**
+ * Gets the Terraform working directory
+ */
+export function getTerraformDir(name) {
+    return path.join(getDeploymentDir(name), "terraform");
+}
+/**
+ * Deletes a deployment and all its files
+ */
+export async function deleteDeployment(name) {
+    const dir = getDeploymentDir(name);
+    await fs.rm(dir, { recursive: true, force: true });
+}
+/**
+ * Updates the deployment state status
+ */
+export async function updateDeploymentStatus(name, status, updates) {
+    const state = await loadDeploymentState(name);
+    if (state) {
+        // Deep merge nested objects like application, infrastructure, dnsRecords
+        const updatedState = {
+            ...state,
+            ...updates,
+            // Deep merge application object to preserve existing fields
+            application: updates?.application
+                ? { ...state.application, ...updates.application }
+                : state.application,
+            // Deep merge infrastructure object
+            infrastructure: updates?.infrastructure
+                ? { ...state.infrastructure, ...updates.infrastructure }
+                : state.infrastructure,
+            status,
+            updatedAt: new Date().toISOString(),
+        };
+        await saveDeploymentState(name, updatedState);
+    }
+}
+// ============================================================================
+// Profile Management - Persistent user preferences across deployments
+// ============================================================================
+/**
+ * Extracts the domain suffix from a full domain.
+ * e.g., "app.example.com" -> ".example.com"
+ * e.g., "sub.app.example.com" -> ".app.example.com"
+ */
+export function extractDomainSuffix(domain) {
+    if (!domain)
+        return undefined;
+    const parts = domain.split(".");
+    if (parts.length < 2)
+        return undefined;
+    // Return everything after the first segment
+    return "." + parts.slice(1).join(".");
+}
+/**
+ * Loads the user profile from ~/.rulebricks/profile.yaml
+ * Returns null if the profile doesn't exist or is invalid
+ */
+export async function loadProfile() {
+    const profilePath = path.join(RULEBRICKS_DIR, PROFILE_FILE);
+    try {
+        const content = await fs.readFile(profilePath, "utf-8");
+        const data = yaml.parse(content);
+        return ProfileConfigSchema.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Saves the user profile to ~/.rulebricks/profile.yaml
+ */
+export async function saveProfile(profile) {
+    await fs.mkdir(RULEBRICKS_DIR, { recursive: true });
+    const profilePath = path.join(RULEBRICKS_DIR, PROFILE_FILE);
+    // Filter out undefined values to keep the file clean
+    const cleanProfile = Object.fromEntries(Object.entries(profile).filter(([_, v]) => v !== undefined));
+    await fs.writeFile(profilePath, yaml.stringify(cleanProfile), "utf-8");
+}
+/**
+ * Extracts profile-worthy values from a deployment configuration.
+ * These are values that are likely to be reused across deployments.
+ */
+export function extractProfileFromConfig(config) {
+    return {
+        // Infrastructure
+        provider: config.infrastructure.provider,
+        region: config.infrastructure.region,
+        clusterName: config.infrastructure.clusterName,
+        infrastructureMode: config.infrastructure.mode,
+        // Domain - store suffix for suggesting new domains
+        domainSuffix: extractDomainSuffix(config.domain),
+        adminEmail: config.adminEmail,
+        tlsEmail: config.tlsEmail,
+        dnsProvider: config.dns.provider,
+        // SMTP
+        smtpHost: config.smtp.host,
+        smtpPort: config.smtp.port,
+        smtpUser: config.smtp.user,
+        smtpPass: config.smtp.pass,
+        smtpFrom: config.smtp.from,
+        smtpFromName: config.smtp.fromName,
+        // API Keys
+        openaiApiKey: config.features.ai.openaiApiKey,
+        licenseKey: config.licenseKey,
+        // Preferences
+        tier: config.tier,
+        databaseType: config.database.type,
+        // SSO
+        ssoProvider: config.features.sso.provider,
+        ssoUrl: config.features.sso.url,
+        ssoClientId: config.features.sso.clientId,
+        ssoClientSecret: config.features.sso.clientSecret,
+    };
+}
+/**
+ * Merges a new profile with an existing one, preferring new non-undefined values.
+ * This allows incremental updates without losing existing preferences.
+ */
+export async function updateProfile(newValues) {
+    const existing = await loadProfile();
+    const merged = {
+        ...existing,
+        ...Object.fromEntries(Object.entries(newValues).filter(([_, v]) => v !== undefined)),
+    };
+    await saveProfile(merged);
+}

package/dist/lib/dns.d.ts

@@ -0,0 +1,41 @@
+import { DNSRecord } from "../types/index.js";
+/**
+ * Checks if a DNS record resolves
+ */
+export declare function checkDNSRecord(hostname: string, expectedTarget?: string): Promise<{
+    resolved: boolean;
+    records: string[];
+    type: "A" | "CNAME" | null;
+    matchesTarget: boolean;
+}>;
+/**
+ * Gets the load balancer address from Kubernetes
+ */
+export declare function getLoadBalancerAddress(namespace?: string): Promise<{
+    address: string | null;
+    type: "ip" | "hostname" | null;
+}>;
+/**
+ * Gets all required DNS records for a deployment
+ */
+export declare function getRequiredDNSRecords(domain: string, loadBalancerAddress: string, loadBalancerType: "ip" | "hostname", selfHostedSupabase: boolean): DNSRecord[];
+/**
+ * Polls DNS records until they resolve or timeout
+ */
+export declare function waitForDNSRecords(records: DNSRecord[], options?: {
+    pollIntervalMs?: number;
+    timeoutMs?: number;
+    onUpdate?: (records: DNSRecord[]) => void;
+}): Promise<{
+    success: boolean;
+    records: DNSRecord[];
+    failedRecords: DNSRecord[];
+}>;
+/**
+ * Formats a DNS record for display
+ */
+export declare function formatDNSRecord(record: DNSRecord): string;
+/**
+ * Checks if DNS propagation is complete for all records
+ */
+export declare function isDNSComplete(records: DNSRecord[]): boolean;

package/dist/lib/dns.js

@@ -0,0 +1,235 @@
+import dns from "dns";
+import { promisify } from "util";
+import { execa } from "execa";
+import { DEFAULT_NAMESPACE } from "../types/index.js";
+const resolve4 = promisify(dns.resolve4);
+const resolveCname = promisify(dns.resolveCname);
+/**
+ * Helper to detect if a string is an IP address
+ */
+function isIPAddress(target) {
+    return /^(\d{1,3}\.){3}\d{1,3}$/.test(target);
+}
+/**
+ * Helper to check if CNAME records match expected target
+ */
+function cnameMatchesTarget(cnameRecords, expectedTarget) {
+    return cnameRecords.some((r) => r === expectedTarget ||
+        r.endsWith(expectedTarget) ||
+        r.replace(/\.$/, "") === expectedTarget.replace(/\.$/, ""));
+}
+/**
+ * Checks if a DNS record resolves
+ */
+export async function checkDNSRecord(hostname, expectedTarget) {
+    try {
+        // If expected target is a hostname (not an IP), check CNAME first
+        if (expectedTarget && !isIPAddress(expectedTarget)) {
+            try {
+                const cnameRecords = await resolveCname(hostname);
+                // CNAME records found - return the comparison result directly
+                // Don't fall through to A record check, as that would incorrectly
+                // compare IPs against a hostname target
+                const matchesTarget = cnameMatchesTarget(cnameRecords, expectedTarget);
+                return {
+                    resolved: true,
+                    records: cnameRecords,
+                    type: "CNAME",
+                    matchesTarget,
+                };
+            }
+            catch {
+                // No CNAME record exists - try A record check
+                // For hostname targets, we need to resolve both the hostname and target
+                // to IPs and compare them
+                try {
+                    const [hostnameIPs, targetIPs] = await Promise.all([
+                        resolve4(hostname),
+                        resolve4(expectedTarget),
+                    ]);
+                    // Check if any of the hostname's IPs match any of the target's IPs
+                    const matchesTarget = hostnameIPs.some((ip) => targetIPs.includes(ip));
+                    return {
+                        resolved: true,
+                        records: hostnameIPs,
+                        type: "A",
+                        matchesTarget,
+                    };
+                }
+                catch {
+                    // Could not resolve - DNS not configured
+                    return {
+                        resolved: false,
+                        records: [],
+                        type: null,
+                        matchesTarget: false,
+                    };
+                }
+            }
+        }
+        // Expected target is an IP address - check A records directly
+        try {
+            const aRecords = await resolve4(hostname);
+            const matchesTarget = expectedTarget
+                ? aRecords.some((r) => r === expectedTarget)
+                : true;
+            return {
+                resolved: true,
+                records: aRecords,
+                type: "A",
+                matchesTarget,
+            };
+        }
+        catch {
+            // Try CNAME if A fails (fallback for when no expected target)
+            const cnameRecords = await resolveCname(hostname);
+            const matchesTarget = expectedTarget
+                ? cnameMatchesTarget(cnameRecords, expectedTarget)
+                : true;
+            return {
+                resolved: true,
+                records: cnameRecords,
+                type: "CNAME",
+                matchesTarget,
+            };
+        }
+    }
+    catch {
+        return {
+            resolved: false,
+            records: [],
+            type: null,
+            matchesTarget: false,
+        };
+    }
+}
+/**
+ * Gets the load balancer address from Kubernetes
+ */
+export async function getLoadBalancerAddress(namespace = DEFAULT_NAMESPACE) {
+    try {
+        // Get the Traefik service which is typically the load balancer
+        const { stdout } = await execa("kubectl", [
+            "get",
+            "service",
+            "-n",
+            namespace,
+            "-l",
+            "app.kubernetes.io/name=traefik",
+            "-o",
+            "jsonpath={.items[0].status.loadBalancer.ingress[0]}",
+        ]);
+        if (!stdout || stdout === "{}") {
+            // Try looking for any LoadBalancer service
+            const { stdout: allServices } = await execa("kubectl", [
+                "get",
+                "service",
+                "-n",
+                namespace,
+                "--field-selector=spec.type=LoadBalancer",
+                "-o",
+                "jsonpath={.items[0].status.loadBalancer.ingress[0]}",
+            ]);
+            if (!allServices || allServices === "{}") {
+                return { address: null, type: null };
+            }
+            const parsed = JSON.parse(allServices || "{}");
+            if (parsed.ip) {
+                return { address: parsed.ip, type: "ip" };
+            }
+            if (parsed.hostname) {
+                return { address: parsed.hostname, type: "hostname" };
+            }
+        }
+        const parsed = JSON.parse(stdout || "{}");
+        if (parsed.ip) {
+            return { address: parsed.ip, type: "ip" };
+        }
+        if (parsed.hostname) {
+            return { address: parsed.hostname, type: "hostname" };
+        }
+        return { address: null, type: null };
+    }
+    catch {
+        return { address: null, type: null };
+    }
+}
+/**
+ * Gets all required DNS records for a deployment
+ */
+export function getRequiredDNSRecords(domain, loadBalancerAddress, loadBalancerType, selfHostedSupabase) {
+    const records = [
+        {
+            hostname: domain,
+            type: loadBalancerType === "ip" ? "A" : "CNAME",
+            target: loadBalancerAddress,
+            verified: false,
+            required: true,
+        },
+    ];
+    // If self-hosted Supabase, need supabase subdomain
+    if (selfHostedSupabase) {
+        records.push({
+            hostname: `supabase.${domain}`,
+            type: loadBalancerType === "ip" ? "A" : "CNAME",
+            target: loadBalancerAddress,
+            verified: false,
+            required: true,
+        });
+    }
+    return records;
+}
+/**
+ * Polls DNS records until they resolve or timeout
+ */
+export async function waitForDNSRecords(records, options = {}) {
+    const { pollIntervalMs = 5000, timeoutMs = 300000, // 5 minutes default
+    onUpdate, } = options;
+    const startTime = Date.now();
+    const updatedRecords = [...records];
+    while (Date.now() - startTime < timeoutMs) {
+        let allResolved = true;
+        for (let i = 0; i < updatedRecords.length; i++) {
+            const record = updatedRecords[i];
+            if (record.verified) {
+                continue;
+            }
+            const result = await checkDNSRecord(record.hostname, record.target);
+            if (result.resolved && result.matchesTarget) {
+                updatedRecords[i] = { ...record, verified: true };
+            }
+            else {
+                allResolved = false;
+            }
+        }
+        onUpdate?.(updatedRecords);
+        if (allResolved) {
+            return {
+                success: true,
+                records: updatedRecords,
+                failedRecords: [],
+            };
+        }
+        // Wait before next poll
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+    // Timeout reached
+    const failedRecords = updatedRecords.filter((r) => !r.verified);
+    return {
+        success: false,
+        records: updatedRecords,
+        failedRecords,
+    };
+}
+/**
+ * Formats a DNS record for display
+ */
+export function formatDNSRecord(record) {
+    return `${record.hostname} → ${record.type} → ${record.target}`;
+}
+/**
+ * Checks if DNS propagation is complete for all records
+ */
+export function isDNSComplete(records) {
+    return records.every((r) => r.verified);
+}

package/dist/lib/dockerHub.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Docker Hub API client for fetching image tags
+ *
+ * Uses the license key as a Docker PAT for authentication
+ * to access private Rulebricks images.
+ */
+/**
+ * Represents a Docker image tag with metadata
+ */
+export interface ImageTag {
+    /** Tag name (e.g., "1.2.3" or "v1.2.3") */
+    name: string;
+    /** When the tag was last updated/pushed */
+    lastUpdated: Date;
+    /** Image digest */
+    digest: string;
+    /** Full image size in bytes */
+    fullSize: number;
+}
+/**
+ * Formats the license key as a Docker PAT
+ */
+export declare function formatDockerPat(licenseKey: string): string;
+/**
+ * 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 declare function authenticateDockerHub(licenseKey: string): Promise<string>;
+/**
+ * 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 declare function fetchImageTags(repo: string, token: string, pageSize?: number): Promise<ImageTag[]>;
+/**
+ * Fetches tags for both app and HPS repositories
+ *
+ * @param licenseKey - The Rulebricks license key
+ * @returns Object containing app and HPS tags
+ */
+export declare function fetchAllImageTags(licenseKey: string): Promise<{
+    appTags: ImageTag[];
+    hpsTags: ImageTag[];
+}>;
+/**
+ * Normalizes a version string by removing leading 'v'
+ */
+export declare function normalizeVersion(version: string): string;
+/**
+ * Formats a version for display (ensures 'v' prefix)
+ */
+export declare function formatVersionDisplay(version: string): string;