@rulebricks/cli 1.9.0

package/README.md

@@ -0,0 +1,62 @@
+![Banner](./banner.png)
+
+The Rulebricks CLI is a management utility that automates the creation and maintenance of private Rulebricks clusters, helping you deploy Rulebricks in customizable, high-throughput configurations on AWS, GCP, or Azure.
+
+You can choose how much you would like the CLI to automate for you– use it to generate valid configuration values, automate infrastructure provisioning (via Terraform), software deployment (via Helm), or all of the above.
+
+## Installation
+
+Try the quick install script (macOS/Linux):
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/rulebricks/cli/main/install.sh | bash
+```
+
+Standalone binaries are available on the [Releases page](https://github.com/rulebricks/cli/releases).
+
+## Prerequisites
+
+You must have a valid **Rulebricks license key**
+to deploy using this CLI. You will be
+requested for this key during project
+configuration.
+
+Rulebricks requires TLS. You will require either external-dns on your cluster to automatically add DNS records, or you will need **access** to manually add **DNS records** for the subdomain(s) where you would like to access your private deployment from.
+
+Finally, you will need to have the following tools installed and ready on your machine:
+
+- **Node.js** >= 20
+- **kubectl** - Kubernetes CLI
+- **Helm** >= 3.0
+- **Terraform** >= 1.0 (for infrastructure provisioning)
+- Cloud CLI (`aws`, `gcloud`, or `az`) configured for your provider
+
+## Quick Start
+
+```bash
+# Configuration wizard (generates values.yaml)
+rulebricks init
+
+# Provision and/or deploy to your cluster
+rulebricks deploy my-deployment
+```
+
+## Commands
+
+| Command                     | Description                            |
+| --------------------------- | -------------------------------------- |
+| `rulebricks init`           | Interactive setup wizard               |
+| `rulebricks deploy [name]`  | Deploy to Kubernetes                   |
+| `rulebricks upgrade [name]` | Upgrade to a new version               |
+| `rulebricks destroy [name]` | Remove a deployment                    |
+| `rulebricks status [name]`  | Show deployment health                 |
+| `rulebricks logs [name]`    | Inspect services                       |
+| `rulebricks open [name]`    | Open the generated configuration files |
+
+Add `-h` to any command to learn more about its options.
+
+## Notes
+
+There are a uniquely wide variety of customization options this CLI makes available (multi-cloud, hybrid vs. self-hosted database deployment, custom email templates, etc.), and not all combinations have been validated.
+
+If you encounter any issue deploying your private Rulebricks cluster, please [email us](mailto:support@rulebricks.com) or [open an issue](https://github.com/rulebricks/cli/issues) and we will follow up promptly.

package/dist/commands/clone.d.ts

@@ -0,0 +1,6 @@
+interface CloneCommandProps {
+    source: string;
+    target: string;
+}
+export declare function CloneCommand(props: CloneCommandProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/commands/clone.js

@@ -0,0 +1,60 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from "react";
+import { Box, Text, useApp } from "ink";
+import { BorderBox, Spinner, ThemeProvider, useTheme, Logo, } from "../components/common/index.js";
+import { deploymentExists, cloneDeploymentConfig, getDeploymentDir, } from "../lib/config.js";
+import { generateHelmValues } from "../lib/helmValues.js";
+function CloneCommandInner({ source, target }) {
+    const { exit } = useApp();
+    const { colors } = useTheme();
+    const [step, setStep] = useState("validating");
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        (async () => {
+            try {
+                // Validate source exists
+                const sourceExists = await deploymentExists(source);
+                if (!sourceExists) {
+                    setError(`Source deployment "${source}" not found`);
+                    setStep("error");
+                    return;
+                }
+                // Validate target doesn't exist
+                const targetExists = await deploymentExists(target);
+                if (targetExists) {
+                    setError(`Target deployment "${target}" already exists`);
+                    setStep("error");
+                    return;
+                }
+                // Clone the configuration
+                setStep("cloning");
+                const clonedConfig = await cloneDeploymentConfig(source, target);
+                // Generate fresh Helm values from the cloned config
+                await generateHelmValues(clonedConfig);
+                setStep("complete");
+                setTimeout(() => exit(), 3000);
+            }
+            catch (err) {
+                setError(err instanceof Error ? err.message : "Failed to clone deployment");
+                setStep("error");
+            }
+        })();
+    }, [source, target, exit]);
+    // Validating screen
+    if (step === "validating") {
+        return (_jsx(BorderBox, { title: "Clone Deployment", children: _jsx(Box, { flexDirection: "column", marginY: 1, children: _jsx(Spinner, { label: "Validating deployments..." }) }) }));
+    }
+    // Error screen
+    if (step === "error") {
+        return (_jsx(BorderBox, { title: "Clone Failed", children: _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Text, { color: colors.error, bold: true, children: "\u2717 Error" }), _jsx(Text, { color: colors.error, children: error }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: colors.muted, dimColor: true, children: ["Use ", _jsx(Text, { color: colors.accent, children: "rulebricks list" }), " to see available deployments."] }) })] }) }));
+    }
+    // Cloning screen
+    if (step === "cloning") {
+        return (_jsx(BorderBox, { title: "Clone Deployment", children: _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsxs(Text, { color: colors.muted, children: ["Source: ", _jsx(Text, { color: colors.accent, children: source })] }), _jsxs(Text, { color: colors.muted, children: ["Target: ", _jsx(Text, { color: colors.accent, children: target })] }), _jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: "Cloning configuration..." }) })] }) }));
+    }
+    // Complete screen
+    return (_jsx(BorderBox, { title: "Clone Complete", children: _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsxs(Text, { color: colors.success, bold: true, children: ["\u2713 Successfully cloned \"", source, "\" to \"", target, "\""] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: colors.muted, children: "Created files:" }), _jsx(Text, { color: colors.muted, children: " \u2022 config.yaml" }), _jsx(Text, { color: colors.muted, children: " \u2022 values.yaml" })] }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsxs(Text, { color: colors.muted, dimColor: true, children: ["Location: ", getDeploymentDir(target)] }) }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: colors.muted, children: "Next steps:" }), _jsxs(Text, { color: colors.accent, children: [" rulebricks deploy ", target] })] })] }) }));
+}
+export function CloneCommand(props) {
+    return (_jsxs(ThemeProvider, { theme: "init", children: [_jsx(Logo, {}), _jsx(CloneCommandInner, { ...props })] }));
+}

package/dist/commands/deploy.d.ts

@@ -0,0 +1,8 @@
+interface DeployCommandProps {
+    name: string;
+    skipInfra?: boolean;
+    skipDns?: boolean;
+    version?: string;
+}
+export declare function DeployCommand(props: DeployCommandProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/commands/deploy.js

@@ -0,0 +1,409 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState, useEffect, useCallback, useRef } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import { BorderBox, Spinner, StatusLine, ThemeProvider, useTheme, Logo, } from "../components/common/index.js";
+import { DNSWaitScreen } from "../components/DNSWaitScreen.js";
+import { loadDeploymentConfig, loadDeploymentState, saveDeploymentState, updateDeploymentStatus, } from "../lib/config.js";
+import { setupTerraformWorkspace, terraformInit, terraformPlan, terraformApply, terraformDestroy, updateKubeconfig, hasTerraformState, isTerraformInstalled, } from "../lib/terraform.js";
+import { installChart, upgradeChart, isHelmInstalled } from "../lib/helm.js";
+import { isKubectlInstalled, checkClusterAccessible, } from "../lib/kubernetes.js";
+import { generateHelmValues, updateHelmValuesForTLS, } from "../lib/helmValues.js";
+import { isSupportedDnsProvider, getNamespace, getReleaseName, } from "../types/index.js";
+function DeployCommandInner({ name, skipInfra, skipDns, version, }) {
+    const { exit } = useApp();
+    const { colors } = useTheme();
+    const [step, setStep] = useState("loading");
+    const [config, setConfig] = useState(null);
+    const [error, setError] = useState(null);
+    const [useExternalDns, setUseExternalDns] = useState(false);
+    const infraStartedRef = useRef(false); // Track if we started infra provisioning (ref for sync access)
+    const [cleanupError, setCleanupError] = useState(null);
+    const [status, setStatus] = useState({
+        preflight: "pending",
+        infrastructure: "pending",
+        kubeconfig: "pending",
+        helmInstall: "pending",
+        dnsConfig: "pending",
+        helmUpgradeTls: "pending",
+    });
+    // Handle cleanup prompt responses
+    const handleCleanup = useCallback(async () => {
+        setStep("cleanup-running");
+        try {
+            await terraformDestroy(name);
+            setStep("cleanup-complete");
+            setTimeout(() => exit(), 3000);
+        }
+        catch (err) {
+            setCleanupError(err instanceof Error ? err.message : "Cleanup failed");
+            setStep("cleanup-complete");
+            setTimeout(() => exit(), 5000);
+        }
+    }, [name, exit]);
+    const skipCleanup = useCallback(() => {
+        setStep("error");
+    }, []);
+    useInput((input, key) => {
+        if (step === "cleanup-prompt") {
+            if (input === "y" || input === "Y") {
+                handleCleanup();
+            }
+            else if (input === "n" || input === "N" || key.escape) {
+                skipCleanup();
+            }
+        }
+        else if (key.escape &&
+            (step === "error" || step === "cleanup-complete")) {
+            exit();
+        }
+    });
+    // Resume after DNS wait (manual DNS flow)
+    const handleDnsComplete = useCallback(async () => {
+        if (!config)
+            return;
+        try {
+            setStep("helm-upgrade-tls");
+            setStatus((s) => ({
+                ...s,
+                dnsConfig: "success",
+                helmUpgradeTls: "running",
+            }));
+            // Update helm values to enable TLS
+            await updateHelmValuesForTLS(name, true);
+            const namespace = getNamespace(config.name);
+            const releaseName = getReleaseName(config.name);
+            // Upgrade the chart with TLS enabled
+            await upgradeChart(name, { releaseName, namespace, version, wait: true });
+            setStatus((s) => ({ ...s, helmUpgradeTls: "success" }));
+            // Update state
+            await updateDeploymentStatus(name, "running", {
+                application: {
+                    appVersion: config.appVersion || "latest",
+                    hpsVersion: config.hpsVersion || config.appVersion || "latest",
+                    chartVersion: version || "latest",
+                    namespace,
+                    url: `https://${config.domain}`,
+                },
+            });
+            setStep("complete");
+            setTimeout(() => exit(), 5000);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : "TLS upgrade failed";
+            setError(message);
+            setStep("error");
+            setStatus((s) => ({ ...s, helmUpgradeTls: "error" }));
+            await updateDeploymentStatus(name, "failed");
+        }
+    }, [config, name, version, exit]);
+    // Skip DNS validation (manual DNS flow)
+    const handleDnsSkip = useCallback(async () => {
+        if (!config)
+            return;
+        setStatus((s) => ({
+            ...s,
+            dnsConfig: "skipped",
+            helmUpgradeTls: "skipped",
+        }));
+        const namespace = getNamespace(config.name);
+        // Mark as running without TLS upgrade
+        await updateDeploymentStatus(name, "running", {
+            application: {
+                appVersion: config.appVersion || "latest",
+                hpsVersion: config.hpsVersion || config.appVersion || "latest",
+                chartVersion: version || "latest",
+                namespace,
+                url: `https://${config.domain}`,
+            },
+        });
+        setStep("complete");
+        setTimeout(() => exit(), 5000);
+    }, [config, name, version, exit]);
+    useEffect(() => {
+        runDeployment();
+    }, []);
+    async function runDeployment() {
+        try {
+            // Load configuration
+            const cfg = await loadDeploymentConfig(name);
+            setConfig(cfg);
+            // Determine if External DNS is enabled
+            // External DNS = supported provider + auto-manage enabled
+            const externalDnsEnabled = cfg.dns.autoManage && isSupportedDnsProvider(cfg.dns.provider);
+            setUseExternalDns(externalDnsEnabled);
+            // Initialize deployment state
+            const existingState = await loadDeploymentState(name);
+            const state = existingState || {
+                name,
+                version: version || "latest",
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                status: "deploying",
+            };
+            await saveDeploymentState(name, { ...state, status: "deploying" });
+            // Preflight checks
+            setStep("preflight");
+            setStatus((s) => ({ ...s, preflight: "running" }));
+            await runPreflightChecks(cfg);
+            setStatus((s) => ({ ...s, preflight: "success" }));
+            // Infrastructure provisioning
+            const needsInfra = cfg.infrastructure.mode === "provision" && !skipInfra;
+            if (needsInfra) {
+                setStatus((s) => ({ ...s, infrastructure: "running" }));
+                infraStartedRef.current = true; // Mark that we're doing infrastructure work
+                // Check if already provisioned
+                const hasState = await hasTerraformState(name);
+                if (!hasState) {
+                    setStep("infra-setup");
+                    await setupTerraformWorkspace(name, cfg.infrastructure.provider);
+                }
+                setStep("infra-init");
+                await terraformInit(name);
+                setStep("infra-plan");
+                await terraformPlan(name);
+                setStep("infra-apply");
+                await terraformApply(name);
+                setStatus((s) => ({ ...s, infrastructure: "success" }));
+                // Update kubeconfig
+                setStep("kubeconfig");
+                setStatus((s) => ({ ...s, kubeconfig: "running" }));
+                await updateKubeconfig(cfg.infrastructure.provider, cfg.infrastructure.clusterName || `${name}-cluster`, cfg.infrastructure.region, {
+                    gcpProjectId: cfg.infrastructure.gcpProjectId,
+                    azureResourceGroup: cfg.infrastructure.azureResourceGroup,
+                });
+                // Note: StorageClass is managed by the Helm chart, not the CLI
+                // This avoids conflicts where kubectl-created resources lack Helm ownership labels
+                setStatus((s) => ({ ...s, kubeconfig: "success" }));
+            }
+            else {
+                // For existing infrastructure, infrastructure is always skipped
+                // kubeconfig may have been updated during preflight if cluster wasn't accessible
+                // (in that case, it's already set to 'success'), otherwise mark as skipped
+                setStatus((s) => ({
+                    ...s,
+                    infrastructure: "skipped",
+                    kubeconfig: s.kubeconfig === "success" ? "success" : "skipped",
+                }));
+            }
+            // Helm Chart Installation
+            setStep("helm-install");
+            setStatus((s) => ({ ...s, helmInstall: "running" }));
+            const namespace = getNamespace(cfg.name);
+            const releaseName = getReleaseName(cfg.name);
+            if (externalDnsEnabled) {
+                // SINGLE-PHASE DEPLOYMENT (External DNS)
+                // Install with TLS enabled from the start - external-dns handles DNS records
+                await generateHelmValues(cfg, { tlsEnabled: true });
+                await installChart(name, {
+                    releaseName,
+                    namespace,
+                    version,
+                    wait: true,
+                });
+                setStatus((s) => ({
+                    ...s,
+                    helmInstall: "success",
+                    dnsConfig: "skipped", // External DNS handles this
+                    helmUpgradeTls: "skipped", // TLS enabled from start
+                }));
+                // Update state to running
+                await updateDeploymentStatus(name, "running", {
+                    application: {
+                        appVersion: cfg.appVersion || "latest",
+                        hpsVersion: cfg.hpsVersion || cfg.appVersion || "latest",
+                        chartVersion: version || "latest",
+                        namespace,
+                        url: `https://${cfg.domain}`,
+                    },
+                });
+                setStep("complete");
+                setTimeout(() => exit(), 5000);
+            }
+            else {
+                // TWO-PHASE DEPLOYMENT (Manual DNS)
+                // Phase 1: Install without TLS
+                await generateHelmValues(cfg, { tlsEnabled: false });
+                await installChart(name, {
+                    releaseName,
+                    namespace,
+                    version,
+                    wait: true,
+                });
+                setStatus((s) => ({ ...s, helmInstall: "success" }));
+                // If skipping DNS, go straight to complete
+                if (skipDns) {
+                    setStatus((s) => ({
+                        ...s,
+                        dnsConfig: "skipped",
+                        helmUpgradeTls: "skipped",
+                    }));
+                    await updateDeploymentStatus(name, "waiting-dns", {
+                        application: {
+                            appVersion: cfg.appVersion || "latest",
+                            hpsVersion: cfg.hpsVersion || cfg.appVersion || "latest",
+                            chartVersion: version || "latest",
+                            namespace,
+                            url: `https://${cfg.domain}`,
+                        },
+                    });
+                    setStep("complete");
+                    setTimeout(() => exit(), 5000);
+                    return;
+                }
+                // Update state to waiting for DNS
+                await updateDeploymentStatus(name, "waiting-dns");
+                // Phase 2: DNS configuration wait
+                setStep("dns-wait");
+                setStatus((s) => ({ ...s, dnsConfig: "running" }));
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : "Unknown error";
+            setError(message);
+            await updateDeploymentStatus(name, "failed");
+            // If we started infrastructure provisioning but failed, offer cleanup
+            if (infraStartedRef.current) {
+                setStep("cleanup-prompt");
+            }
+            else {
+                setStep("error");
+            }
+        }
+    }
+    async function runPreflightChecks(cfg) {
+        // Check required tools
+        const [helm, kubectl, terraform] = await Promise.all([
+            isHelmInstalled(),
+            isKubectlInstalled(),
+            isTerraformInstalled(),
+        ]);
+        if (!helm) {
+            throw new Error("Helm is not installed. Please install Helm first.");
+        }
+        if (!kubectl) {
+            throw new Error("kubectl is not installed. Please install kubectl first.");
+        }
+        if (cfg.infrastructure.mode === "provision" && !terraform) {
+            throw new Error("Terraform is not installed. Required for infrastructure provisioning.");
+        }
+        // Check cluster access if using existing infrastructure
+        if (cfg.infrastructure.mode === "existing") {
+            let clusterError = await checkClusterAccessible();
+            // If cluster not accessible but we have provider details, try updating kubeconfig
+            if (clusterError &&
+                cfg.infrastructure.provider &&
+                cfg.infrastructure.region &&
+                cfg.infrastructure.clusterName) {
+                try {
+                    // Show visual feedback for kubeconfig update
+                    setStep("kubeconfig");
+                    setStatus((s) => ({
+                        ...s,
+                        preflight: "success",
+                        kubeconfig: "running",
+                    }));
+                    await updateKubeconfig(cfg.infrastructure.provider, cfg.infrastructure.clusterName, cfg.infrastructure.region, {
+                        gcpProjectId: cfg.infrastructure.gcpProjectId,
+                        azureResourceGroup: cfg.infrastructure.azureResourceGroup,
+                    });
+                    // Retry cluster access check
+                    clusterError = await checkClusterAccessible();
+                    if (!clusterError) {
+                        setStatus((s) => ({ ...s, kubeconfig: "success" }));
+                    }
+                }
+                catch (kubeconfigError) {
+                    // Kubeconfig update failed, include both errors
+                    const kubeconfigMsg = kubeconfigError instanceof Error
+                        ? kubeconfigError.message
+                        : "Unknown error";
+                    throw new Error(`Cannot access Kubernetes cluster and kubeconfig update failed:\n` +
+                        `Cluster error: ${clusterError}\n` +
+                        `Kubeconfig update error: ${kubeconfigMsg}`);
+                }
+            }
+            if (clusterError) {
+                // Provide helpful message based on whether provider details are missing
+                if (!cfg.infrastructure.provider ||
+                    !cfg.infrastructure.region ||
+                    !cfg.infrastructure.clusterName) {
+                    throw new Error(`Cannot access Kubernetes cluster:\n${clusterError}\n\n` +
+                        `Tip: Re-run 'rulebricks init' and provide your cloud provider, region, and cluster name ` +
+                        `to enable automatic kubeconfig updates.`);
+                }
+                throw new Error(`Cannot access Kubernetes cluster:\n${clusterError}`);
+            }
+        }
+    }
+    // Cleanup prompt screen
+    if (step === "cleanup-prompt") {
+        return (_jsx(BorderBox, { title: "Deployment Failed", children: _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Text, { color: colors.error, bold: true, children: "\u2717 Infrastructure provisioning failed" }), _jsx(Text, { color: colors.error, children: error }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: colors.warning, bold: true, children: "Partial infrastructure may have been created." }), _jsx(Text, { color: colors.muted, children: "Would you like to clean up to avoid orphaned resources?" })] }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: colors.accent, bold: true, children: "[Y]" }), _jsxs(Text, { color: colors.muted, children: [" ", "Yes, destroy partial infrastructure"] })] }), _jsxs(Box, { children: [_jsx(Text, { color: colors.accent, bold: true, children: "[N]" }), _jsxs(Text, { color: colors.muted, children: [" ", "No, keep for debugging (you can run `rulebricks destroy --cluster` later)"] })] })] }) }));
+    }
+    // Cleanup running screen
+    if (step === "cleanup-running") {
+        return (_jsx(BorderBox, { title: "Cleaning Up", children: _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Spinner, { label: "Destroying partial infrastructure..." }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: colors.muted, children: "This may take several minutes..." }) })] }) }));
+    }
+    // Cleanup complete screen
+    if (step === "cleanup-complete") {
+        return (_jsx(BorderBox, { title: "Cleanup Complete", children: _jsxs(Box, { flexDirection: "column", marginY: 1, children: [cleanupError ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: colors.warning, bold: true, children: "\u26A0 Cleanup encountered issues" }), _jsx(Text, { color: colors.warning, children: cleanupError }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: colors.muted, children: ["Some resources may remain. Run `rulebricks destroy ", name, " ", "--cluster` to retry."] }) })] })) : (_jsxs(_Fragment, { children: [_jsx(Text, { color: colors.success, bold: true, children: "\u2713 Infrastructure cleaned up successfully" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: colors.muted, children: "All partial resources have been destroyed. You can try deploying again." }) })] })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: colors.muted, dimColor: true, children: "Press Esc to exit" }) })] }) }));
+    }
+    // Error screen (non-infra failures or when user skips cleanup)
+    if (step === "error") {
+        // Format error message, preserving newlines for multi-line errors
+        const errorLines = error?.split("\n") || ["Unknown error"];
+        return (_jsx(BorderBox, { title: "Deployment Failed", children: _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Text, { color: colors.error, bold: true, children: "\u2717 Error" }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: errorLines.map((line, i) => (_jsx(Text, { color: line.startsWith("  •") ? colors.muted : colors.error, children: line }, i))) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: colors.muted, dimColor: true, children: "Press Esc to exit" }) })] }) }));
+    }
+    // DNS wait screen (only for manual DNS flow)
+    if (step === "dns-wait" && config) {
+        return (_jsx(DNSWaitScreen, { domain: config.domain, selfHostedSupabase: config.database.type === "self-hosted", namespace: getNamespace(config.name), onComplete: handleDnsComplete, onSkip: handleDnsSkip }));
+    }
+    // Complete screen
+    if (step === "complete") {
+        const tlsSkipped = status.helmUpgradeTls === "skipped" && !useExternalDns;
+        return (_jsx(BorderBox, { title: "Deployment Complete", children: _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Text, { color: colors.success, bold: true, children: "\u2713 Rulebricks deployed successfully!" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { children: ["URL:", " ", _jsxs(Text, { color: colors.accent, children: ["https://", config?.domain, "/auth/signup"] })] }), useExternalDns && (_jsx(Text, { color: colors.muted, children: "DNS records will be created automatically by external-dns" })), tlsSkipped && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: colors.warning, children: ["\u26A0 TLS not configured. Run `rulebricks deploy ", name, "` again after DNS setup."] }) }))] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Next steps:" }), _jsxs(Text, { color: colors.muted, children: [" ", "\u2022 Visit the URL to complete initial setup"] }), _jsxs(Text, { color: colors.muted, children: [" ", "\u2022 Run `rulebricks status ", name, "` to check deployment health"] }), tlsSkipped && (_jsxs(Text, { color: colors.muted, children: [" ", "\u2022 Configure DNS and re-run deploy for TLS"] }))] })] }) }));
+    }
+    // Progress screen
+    const helmInstallLabel = useExternalDns
+        ? "Helm chart installation (with TLS)"
+        : "Helm chart installation";
+    return (_jsx(BorderBox, { title: `Deploying ${name}`, children: _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(StatusLine, { status: status.preflight, label: "Preflight checks" }), _jsx(StatusLine, { status: status.infrastructure, label: "Infrastructure provisioning", detail: step === "infra-setup"
+                        ? "Setting up workspace"
+                        : step === "infra-init"
+                            ? "Initializing Terraform"
+                            : step === "infra-plan"
+                                ? "Planning changes"
+                                : step === "infra-apply"
+                                    ? "Applying infrastructure"
+                                    : undefined }), _jsx(StatusLine, { status: status.kubeconfig, label: "Kubernetes configuration" }), _jsx(StatusLine, { status: status.helmInstall, label: helmInstallLabel }), !useExternalDns && (_jsxs(_Fragment, { children: [_jsx(StatusLine, { status: status.dnsConfig, label: "DNS configuration" }), _jsx(StatusLine, { status: status.helmUpgradeTls, label: "TLS configuration" })] })), step !== "dns-wait" && (_jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: getStepLabel(step, useExternalDns) }) }))] }) }));
+}
+function getStepLabel(step, useExternalDns) {
+    switch (step) {
+        case "loading":
+            return "Loading configuration...";
+        case "preflight":
+            return "Running preflight checks...";
+        case "infra-setup":
+            return "Setting up Terraform workspace...";
+        case "infra-init":
+            return "Initializing Terraform...";
+        case "infra-plan":
+            return "Planning infrastructure changes...";
+        case "infra-apply":
+            return "Creating infrastructure (may take up to 15 minutes)...";
+        case "kubeconfig":
+            return "Updating kubeconfig...";
+        case "helm-install":
+            return useExternalDns
+                ? "Installing Helm chart with TLS..."
+                : "Installing Helm chart...";
+        case "dns-wait":
+            return "Waiting for DNS configuration...";
+        case "helm-upgrade-tls":
+            return "Enabling TLS certificates...";
+        default:
+            return "Processing...";
+    }
+}
+export function DeployCommand(props) {
+    return (_jsxs(ThemeProvider, { theme: "deploy", children: [_jsx(Logo, {}), _jsx(DeployCommandInner, { ...props })] }));
+}

package/dist/commands/destroy.d.ts

@@ -0,0 +1,8 @@
+interface DestroyCommandProps {
+    name: string;
+    cluster?: boolean;
+    config?: boolean;
+    force?: boolean;
+}
+export declare function DestroyCommand(props: DestroyCommandProps): import("react/jsx-runtime").JSX.Element;
+export {};