@rulebricks/cli 1.9.0

package/dist/lib/terraform.d.ts

@@ -0,0 +1,44 @@
+import { CloudProvider } from '../types/index.js';
+/**
+ * Checks if Terraform is installed
+ */
+export declare function isTerraformInstalled(): Promise<boolean>;
+/**
+ * Gets the installed Terraform version
+ */
+export declare function getTerraformVersion(): Promise<string>;
+/**
+ * Copies terraform templates to the deployment directory
+ */
+export declare function setupTerraformWorkspace(deploymentName: string, provider: CloudProvider): Promise<string>;
+/**
+ * Initializes Terraform in the deployment directory
+ */
+export declare function terraformInit(deploymentName: string): Promise<void>;
+/**
+ * Plans Terraform changes
+ */
+export declare function terraformPlan(deploymentName: string): Promise<void>;
+/**
+ * Applies Terraform changes
+ */
+export declare function terraformApply(deploymentName: string): Promise<void>;
+/**
+ * Destroys Terraform infrastructure
+ */
+export declare function terraformDestroy(deploymentName: string): Promise<void>;
+/**
+ * Gets Terraform outputs
+ */
+export declare function getTerraformOutputs(deploymentName: string): Promise<Record<string, string>>;
+/**
+ * Checks if Terraform state exists for a deployment
+ */
+export declare function hasTerraformState(deploymentName: string): Promise<boolean>;
+/**
+ * Updates kubeconfig for the provisioned cluster
+ */
+export declare function updateKubeconfig(provider: CloudProvider, clusterName: string, region: string, options?: {
+    gcpProjectId?: string;
+    azureResourceGroup?: string;
+}): Promise<void>;

package/dist/lib/terraform.js

@@ -0,0 +1,230 @@
+import { execa } from 'execa';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { getTerraformDir } from './config.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Path to embedded terraform templates
+const TERRAFORM_TEMPLATES_DIR = path.resolve(__dirname, '../../terraform');
+/**
+ * Extracts meaningful error message from execa error
+ */
+function getErrorMessage(error, fallback) {
+    const execaError = error;
+    // Try stderr first, then stdout (terraform sometimes writes errors to 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 || fallback;
+}
+/**
+ * Saves command output to a log file
+ */
+async function saveLogFile(workDir, command, stdout, stderr) {
+    const logFile = path.join(workDir, `${command}-${Date.now()}.log`);
+    const content = `=== STDOUT ===\n${stdout}\n\n=== STDERR ===\n${stderr}`;
+    await fs.writeFile(logFile, content);
+    return logFile;
+}
+/**
+ * Checks if Terraform is installed
+ */
+export async function isTerraformInstalled() {
+    try {
+        await execa('terraform', ['version']);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Gets the installed Terraform version
+ */
+export async function getTerraformVersion() {
+    const { stdout } = await execa('terraform', ['version', '-json']);
+    const info = JSON.parse(stdout);
+    return info.terraform_version;
+}
+/**
+ * Copies terraform templates to the deployment directory
+ */
+export async function setupTerraformWorkspace(deploymentName, provider) {
+    const sourceDir = path.join(TERRAFORM_TEMPLATES_DIR, provider);
+    const targetDir = getTerraformDir(deploymentName);
+    // Create target directory
+    await fs.mkdir(targetDir, { recursive: true });
+    // Copy all terraform files
+    await copyDirectory(sourceDir, targetDir);
+    return targetDir;
+}
+/**
+ * Recursively copies a directory
+ */
+async function copyDirectory(src, dest) {
+    await fs.mkdir(dest, { recursive: true });
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirectory(srcPath, destPath);
+        }
+        else {
+            await fs.copyFile(srcPath, destPath);
+        }
+    }
+}
+/**
+ * Initializes Terraform in the deployment directory
+ */
+export async function terraformInit(deploymentName) {
+    const workDir = getTerraformDir(deploymentName);
+    try {
+        // Use 'pipe' to capture output instead of 'inherit' to avoid
+        // interfering with Ink's terminal rendering
+        await execa('terraform', ['init', '-upgrade'], {
+            cwd: workDir
+        });
+    }
+    catch (error) {
+        const execaError = error;
+        // Save logs for debugging
+        if (execaError.stdout || execaError.stderr) {
+            await saveLogFile(workDir, 'init', execaError.stdout || '', execaError.stderr || '');
+        }
+        throw new Error(`Terraform init failed:\n${getErrorMessage(error, 'Unknown error')}\n\nLogs saved to: ${workDir}`);
+    }
+}
+/**
+ * Plans Terraform changes
+ */
+export async function terraformPlan(deploymentName) {
+    const workDir = getTerraformDir(deploymentName);
+    try {
+        await execa('terraform', ['plan', '-out=tfplan'], {
+            cwd: workDir
+        });
+    }
+    catch (error) {
+        const execaError = error;
+        if (execaError.stdout || execaError.stderr) {
+            await saveLogFile(workDir, 'plan', execaError.stdout || '', execaError.stderr || '');
+        }
+        throw new Error(`Terraform plan failed:\n${getErrorMessage(error, 'Unknown error')}\n\nLogs saved to: ${workDir}`);
+    }
+}
+/**
+ * Applies Terraform changes
+ */
+export async function terraformApply(deploymentName) {
+    const workDir = getTerraformDir(deploymentName);
+    try {
+        await execa('terraform', ['apply', '-auto-approve', 'tfplan'], {
+            cwd: workDir
+        });
+    }
+    catch (error) {
+        const execaError = error;
+        if (execaError.stdout || execaError.stderr) {
+            await saveLogFile(workDir, 'apply', execaError.stdout || '', execaError.stderr || '');
+        }
+        throw new Error(`Terraform apply failed:\n${getErrorMessage(error, 'Unknown error')}\n\nLogs saved to: ${workDir}`);
+    }
+}
+/**
+ * Destroys Terraform infrastructure
+ */
+export async function terraformDestroy(deploymentName) {
+    const workDir = getTerraformDir(deploymentName);
+    try {
+        await execa('terraform', ['destroy', '-auto-approve'], {
+            cwd: workDir
+        });
+    }
+    catch (error) {
+        const execaError = error;
+        if (execaError.stdout || execaError.stderr) {
+            await saveLogFile(workDir, 'destroy', execaError.stdout || '', execaError.stderr || '');
+        }
+        throw new Error(`Terraform destroy failed:\n${getErrorMessage(error, 'Unknown error')}\n\nLogs saved to: ${workDir}`);
+    }
+}
+/**
+ * Gets Terraform outputs
+ */
+export async function getTerraformOutputs(deploymentName) {
+    const workDir = getTerraformDir(deploymentName);
+    try {
+        const { stdout } = await execa('terraform', ['output', '-json'], {
+            cwd: workDir
+        });
+        const outputs = JSON.parse(stdout);
+        const result = {};
+        for (const [key, data] of Object.entries(outputs)) {
+            result[key] = String(data.value);
+        }
+        return result;
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Checks if Terraform state exists for a deployment
+ */
+export async function hasTerraformState(deploymentName) {
+    const workDir = getTerraformDir(deploymentName);
+    const statePath = path.join(workDir, 'terraform.tfstate');
+    try {
+        await fs.access(statePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Updates kubeconfig for the provisioned cluster
+ */
+export async function updateKubeconfig(provider, clusterName, region, options = {}) {
+    try {
+        switch (provider) {
+            case 'aws':
+                await execa('aws', [
+                    'eks', 'update-kubeconfig',
+                    '--name', clusterName,
+                    '--region', region
+                ]);
+                break;
+            case 'gcp':
+                if (!options.gcpProjectId) {
+                    throw new Error('GCP project ID is required');
+                }
+                await execa('gcloud', [
+                    'container', 'clusters', 'get-credentials',
+                    clusterName,
+                    '--region', region,
+                    '--project', options.gcpProjectId
+                ]);
+                break;
+            case 'azure':
+                if (!options.azureResourceGroup) {
+                    throw new Error('Azure resource group is required');
+                }
+                await execa('az', [
+                    'aks', 'get-credentials',
+                    '--name', clusterName,
+                    '--resource-group', options.azureResourceGroup
+                ]);
+                break;
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to update kubeconfig:\n${getErrorMessage(error, 'Unknown error')}`);
+    }
+}

package/dist/lib/theme.d.ts

@@ -0,0 +1,81 @@
+import React, { ReactNode } from "react";
+/**
+ * Command theme types - each command has its own visual identity
+ */
+export type CommandTheme = "init" | "deploy" | "upgrade" | "destroy" | "status" | "logs";
+/**
+ * Theme color configuration
+ */
+export interface ThemeColors {
+    /** Primary accent color for borders, highlights */
+    accent: string;
+    /** Brighter variant for emphasis */
+    accentBright: string;
+    /** Color for selected/active items */
+    selected: string;
+    /** Color for success states */
+    success: string;
+    /** Color for error states */
+    error: string;
+    /** Color for warning states */
+    warning: string;
+    /** Dimmed/muted color */
+    muted: string;
+}
+/**
+ * Theme definitions for each command
+ *
+ * - init: Magenta - fresh start, creative setup
+ * - deploy: Blue - action, progress, trust
+ * - upgrade: #ea9d34 - caution, change, attention
+ * - destroy: Red - danger, destructive action
+ * - status: #4c9c81 - health, success, information
+ * - logs: #c2b5ab - neutral, observational
+ */
+export declare const THEMES: Record<CommandTheme, ThemeColors>;
+/**
+ * Default theme (used when no provider is present)
+ */
+export declare const DEFAULT_THEME: CommandTheme;
+/**
+ * Theme context value
+ */
+interface ThemeContextValue {
+    theme: CommandTheme;
+    colors: ThemeColors;
+}
+/**
+ * ThemeProvider props
+ */
+interface ThemeProviderProps {
+    theme: CommandTheme;
+    children: ReactNode;
+}
+/**
+ * ThemeProvider component - wraps a command to provide themed styling
+ *
+ * @example
+ * ```tsx
+ * <ThemeProvider theme="destroy">
+ *   <DestroyCommand />
+ * </ThemeProvider>
+ * ```
+ */
+export declare function ThemeProvider({ theme, children, }: ThemeProviderProps): React.ReactElement;
+/**
+ * Hook to access current theme colors
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { colors } = useTheme();
+ *   return <Text color={colors.accent}>Themed text</Text>;
+ * }
+ * ```
+ */
+export declare function useTheme(): ThemeContextValue;
+/**
+ * Get theme colors directly without hook (for non-component code)
+ */
+export declare function getThemeColors(theme: CommandTheme): ThemeColors;
+export {};

package/dist/lib/theme.js

@@ -0,0 +1,115 @@
+import React, { createContext, useContext } from "react";
+/**
+ * Theme definitions for each command
+ *
+ * - init: Magenta - fresh start, creative setup
+ * - deploy: Blue - action, progress, trust
+ * - upgrade: #ea9d34 - caution, change, attention
+ * - destroy: Red - danger, destructive action
+ * - status: #4c9c81 - health, success, information
+ * - logs: #c2b5ab - neutral, observational
+ */
+export const THEMES = {
+    init: {
+        accent: "#c4a7e7",
+        accentBright: "#a78bc7",
+        selected: "#c4a7e7",
+        success: "#4c9c81",
+        error: "#d7827e",
+        warning: "#ea9d34",
+        muted: "#c2b5ab",
+    },
+    deploy: {
+        accent: "#64a5b0",
+        accentBright: "#5fbac9",
+        selected: "#64a5b0",
+        success: "#4c9c81",
+        error: "#d7827e",
+        warning: "#ea9d34",
+        muted: "#c2b5ab",
+    },
+    upgrade: {
+        accent: "#3e8fb0",
+        accentBright: "#5aabcc",
+        selected: "#3e8fb0",
+        success: "#4c9c81",
+        error: "#d7827e",
+        warning: "#ea9d34",
+        muted: "#c2b5ab",
+    },
+    destroy: {
+        accent: "#d7827e",
+        accentBright: "#ea9a97",
+        selected: "#d7827e",
+        success: "#4c9c81",
+        error: "#d7827e",
+        warning: "#cf6d69",
+        muted: "#a18581",
+    },
+    status: {
+        accent: "#4c9c81",
+        accentBright: "#4c9c81",
+        selected: "#4c9c81",
+        success: "#4c9c81",
+        error: "#d7827e",
+        warning: "#ea9d34",
+        muted: "#c2b5ab",
+    },
+    logs: {
+        accent: "#524f67",
+        accentBright: "#56526e",
+        selected: "#cecacd",
+        success: "#4c9c81",
+        error: "#d7827e",
+        warning: "#ea9d34",
+        muted: "#c2b5ab",
+    },
+};
+/**
+ * Default theme (used when no provider is present)
+ */
+export const DEFAULT_THEME = "init";
+/**
+ * Theme context - provides current theme to all child components
+ */
+const ThemeContext = createContext({
+    theme: DEFAULT_THEME,
+    colors: THEMES[DEFAULT_THEME],
+});
+/**
+ * ThemeProvider component - wraps a command to provide themed styling
+ *
+ * @example
+ * ```tsx
+ * <ThemeProvider theme="destroy">
+ *   <DestroyCommand />
+ * </ThemeProvider>
+ * ```
+ */
+export function ThemeProvider({ theme, children, }) {
+    const value = {
+        theme,
+        colors: THEMES[theme],
+    };
+    return React.createElement(ThemeContext.Provider, { value }, children);
+}
+/**
+ * Hook to access current theme colors
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { colors } = useTheme();
+ *   return <Text color={colors.accent}>Themed text</Text>;
+ * }
+ * ```
+ */
+export function useTheme() {
+    return useContext(ThemeContext);
+}
+/**
+ * Get theme colors directly without hook (for non-component code)
+ */
+export function getThemeColors(theme) {
+    return THEMES[theme];
+}

package/dist/lib/validation.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Validates an email address using a comprehensive regex
+ */
+export declare function isValidEmail(email: string): boolean;
+/**
+ * Extracts the base domain from a full domain name
+ * e.g., "rulebricks.example.com" -> "example.com"
+ */
+export declare function extractBaseDomain(fullDomain: string): string;
+/**
+ * Validates that a domain is properly formatted
+ */
+export declare function isValidDomainFormat(domain: string): boolean;
+/**
+ * Checks if the base domain has active DNS records
+ */
+export declare function validateBaseDomain(fullDomain: string): Promise<{
+    valid: boolean;
+    baseDomain: string;
+    error?: string;
+}>;
+/**
+ * Checks if a specific hostname resolves to a given target
+ */
+export declare function checkDNSRecord(hostname: string, expectedTarget?: string): Promise<{
+    resolved: boolean;
+    records: string[];
+    matchesTarget: boolean;
+}>;
+/**
+ * Validates SMTP configuration format
+ */
+export declare function validateSMTPConfig(config: {
+    host: string;
+    port: number;
+    user: string;
+    pass: string;
+    from: string;
+    fromName: string;
+}): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Generates a secure random string for secrets
+ */
+export declare function generateSecureSecret(length?: number): string;

package/dist/lib/validation.js

@@ -0,0 +1,164 @@
+import dns from 'dns';
+import { promisify } from 'util';
+const resolveDns = promisify(dns.resolve);
+const resolve4 = promisify(dns.resolve4);
+const resolveCname = promisify(dns.resolveCname);
+/**
+ * Validates an email address using a comprehensive regex
+ */
+export function isValidEmail(email) {
+    const emailRegex = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+    return emailRegex.test(email) && email.length <= 254;
+}
+/**
+ * Extracts the base domain from a full domain name
+ * e.g., "rulebricks.example.com" -> "example.com"
+ */
+export function extractBaseDomain(fullDomain) {
+    const parts = fullDomain.toLowerCase().split('.');
+    // Handle common multi-part TLDs
+    const multiPartTlds = ['co.uk', 'com.au', 'co.nz', 'co.jp', 'com.br', 'co.za'];
+    if (parts.length >= 3) {
+        const lastTwo = `${parts[parts.length - 2]}.${parts[parts.length - 1]}`;
+        if (multiPartTlds.includes(lastTwo)) {
+            // For multi-part TLDs, take the last 3 parts
+            return parts.slice(-3).join('.');
+        }
+    }
+    // For standard TLDs, take the last 2 parts
+    if (parts.length >= 2) {
+        return parts.slice(-2).join('.');
+    }
+    return fullDomain;
+}
+/**
+ * Validates that a domain is properly formatted
+ */
+export function isValidDomainFormat(domain) {
+    // Basic domain format validation
+    const domainRegex = /^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
+    return domainRegex.test(domain);
+}
+/**
+ * Checks if the base domain has active DNS records
+ */
+export async function validateBaseDomain(fullDomain) {
+    if (!isValidDomainFormat(fullDomain)) {
+        return {
+            valid: false,
+            baseDomain: '',
+            error: 'Invalid domain format'
+        };
+    }
+    const baseDomain = extractBaseDomain(fullDomain);
+    try {
+        // Try to resolve the base domain
+        // First try A records
+        try {
+            await resolve4(baseDomain);
+            return { valid: true, baseDomain };
+        }
+        catch {
+            // If A record fails, try any record type
+            await resolveDns(baseDomain, 'ANY');
+            return { valid: true, baseDomain };
+        }
+    }
+    catch (err) {
+        const error = err;
+        if (error.code === 'ENOTFOUND') {
+            return {
+                valid: false,
+                baseDomain,
+                error: `Base domain "${baseDomain}" does not exist or has no DNS records`
+            };
+        }
+        if (error.code === 'ENODATA') {
+            // Domain exists but no records of the requested type
+            // This is actually OK for our purposes
+            return { valid: true, baseDomain };
+        }
+        // For other errors, assume the domain might be valid
+        // (could be temporary DNS issues)
+        return { valid: true, baseDomain };
+    }
+}
+/**
+ * Checks if a specific hostname resolves to a given target
+ */
+export async function checkDNSRecord(hostname, expectedTarget) {
+    try {
+        // Try A record first
+        try {
+            const aRecords = await resolve4(hostname);
+            const matchesTarget = expectedTarget
+                ? aRecords.some(r => r === expectedTarget)
+                : true;
+            return {
+                resolved: true,
+                records: aRecords,
+                matchesTarget
+            };
+        }
+        catch {
+            // Try CNAME
+            const cnameRecords = await resolveCname(hostname);
+            const matchesTarget = expectedTarget
+                ? cnameRecords.some(r => r === expectedTarget || r.endsWith(expectedTarget))
+                : true;
+            return {
+                resolved: true,
+                records: cnameRecords,
+                matchesTarget
+            };
+        }
+    }
+    catch {
+        return {
+            resolved: false,
+            records: [],
+            matchesTarget: false
+        };
+    }
+}
+/**
+ * Validates SMTP configuration format
+ */
+export function validateSMTPConfig(config) {
+    const errors = [];
+    if (!config.host || config.host.length < 3) {
+        errors.push('SMTP host is required');
+    }
+    if (!config.port || config.port < 1 || config.port > 65535) {
+        errors.push('SMTP port must be between 1 and 65535');
+    }
+    if (!config.user) {
+        errors.push('SMTP username is required');
+    }
+    if (!config.pass) {
+        errors.push('SMTP password is required');
+    }
+    if (!config.from || !isValidEmail(config.from)) {
+        errors.push('Valid SMTP from address is required');
+    }
+    if (!config.fromName || config.fromName.length < 1) {
+        errors.push('SMTP from name is required');
+    }
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}
+/**
+ * Generates a secure random string for secrets
+ */
+export function generateSecureSecret(length = 32) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    const randomValues = new Uint8Array(length);
+    crypto.getRandomValues(randomValues);
+    for (let i = 0; i < length; i++) {
+        result += chars[randomValues[i] % chars.length];
+    }
+    return result;
+}