@rulebricks/cli 1.9.0

package/dist/commands/destroy.js

@@ -0,0 +1,298 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import React, { useState, useCallback } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import { BorderBox, Spinner, StatusLine, ThemeProvider, useTheme, Logo, } from "../components/common/index.js";
+import { loadDeploymentConfig, loadDeploymentState, deleteDeployment, deploymentExists, } from "../lib/config.js";
+import { uninstallChart, getInstalledVersion } from "../lib/helm.js";
+import { terraformDestroy, hasTerraformState } from "../lib/terraform.js";
+import { deleteNamespace, deletePVCs, isClusterAccessible, namespaceExists, removeKedaFinalizers, } from "../lib/kubernetes.js";
+import { getNamespace, getReleaseName, } from "../types/index.js";
+function DestroyCommandInner({ name, cluster, config, force, }) {
+    const { exit } = useApp();
+    const { colors } = useTheme();
+    const [step, setStep] = useState("loading");
+    const [deploymentConfig, setDeploymentConfig] = useState(null);
+    const [state, setState] = useState(null);
+    const [scope, setScope] = useState(null);
+    const [error, setError] = useState(null);
+    const [confirmText, setConfirmText] = useState("");
+    const [status, setStatus] = useState({
+        helm: "pending",
+        pvc: "pending",
+        namespace: "pending",
+        infrastructure: "pending",
+        cleanup: "pending",
+    });
+    // Load config and determine scope on mount
+    React.useEffect(() => {
+        (async () => {
+            try {
+                // Check if deployment exists
+                const exists = await deploymentExists(name);
+                if (!exists) {
+                    setError(`Deployment "${name}" not found`);
+                    setStep("error");
+                    return;
+                }
+                // Load config (may throw if corrupted)
+                let cfg = null;
+                try {
+                    cfg = await loadDeploymentConfig(name);
+                    setDeploymentConfig(cfg);
+                }
+                catch {
+                    // Config might be corrupted or missing, that's OK for destroy
+                }
+                // Load state
+                const st = await loadDeploymentState(name);
+                setState(st);
+                // Determine what was actually deployed
+                const deploymentScope = await determineScope(name, cfg, st);
+                setScope(deploymentScope);
+                if (force) {
+                    setStep("destroying");
+                    runDestroy(cfg, st, deploymentScope);
+                }
+                else {
+                    setStep("confirm");
+                }
+            }
+            catch (err) {
+                setError(err instanceof Error ? err.message : "Failed to load deployment");
+                setStep("error");
+            }
+        })();
+    }, [name, force]);
+    useInput((input, key) => {
+        if (step === "confirm") {
+            if (key.return) {
+                if (cluster && scope?.hasInfrastructure) {
+                    if (confirmText === "destroy-all") {
+                        setStep("destroying");
+                        runDestroy(deploymentConfig, state, scope);
+                    }
+                }
+                else {
+                    setStep("destroying");
+                    runDestroy(deploymentConfig, state, scope);
+                }
+            }
+            else if (key.escape) {
+                exit();
+            }
+            else if (key.backspace || key.delete) {
+                setConfirmText((t) => t.slice(0, -1));
+            }
+            else if (input && !key.ctrl && !key.meta) {
+                setConfirmText((t) => t + input);
+            }
+        }
+        else if (step === "error") {
+            if (key.escape || key.return) {
+                exit();
+            }
+        }
+    });
+    const runDestroy = useCallback(async (cfg, st, deploymentScope) => {
+        try {
+            // Use namespace from state if available (backwards compat), otherwise compute from deployment name
+            const namespace = st?.application?.namespace || getNamespace(name);
+            const releaseName = getReleaseName(name);
+            // Run cluster cleanup if cluster is accessible
+            if (deploymentScope.clusterAccessible) {
+                // Step 1: Uninstall Helm release (only if namespace exists - helm data is stored there)
+                if (deploymentScope.hasHelmRelease && deploymentScope.hasNamespace) {
+                    setStatus((s) => ({ ...s, helm: "running" }));
+                    try {
+                        await uninstallChart(releaseName, namespace, { wait: false });
+                        setStatus((s) => ({ ...s, helm: "success" }));
+                    }
+                    catch {
+                        // Helm release might already be gone, continue anyway
+                        setStatus((s) => ({ ...s, helm: "error" }));
+                    }
+                }
+                else {
+                    // Skip if no helm release OR namespace is already gone
+                    setStatus((s) => ({ ...s, helm: "skipped" }));
+                }
+                // Step 2: Delete all PVCs in the namespace
+                if (deploymentScope.hasNamespace) {
+                    setStatus((s) => ({ ...s, pvc: "running" }));
+                    try {
+                        await deletePVCs(namespace);
+                        setStatus((s) => ({ ...s, pvc: "success" }));
+                    }
+                    catch {
+                        // PVCs might not exist, continue anyway
+                        setStatus((s) => ({ ...s, pvc: "error" }));
+                    }
+                }
+                else {
+                    setStatus((s) => ({ ...s, pvc: "skipped" }));
+                }
+                // Step 3: Delete namespace
+                if (deploymentScope.hasNamespace) {
+                    setStatus((s) => ({ ...s, namespace: "running" }));
+                    try {
+                        // Remove KEDA finalizers first to prevent namespace deletion from hanging
+                        // KEDA finalizers wait for KEDA controller, but it's being deleted too
+                        await removeKedaFinalizers(namespace);
+                        await deleteNamespace(namespace);
+                        setStatus((s) => ({ ...s, namespace: "success" }));
+                    }
+                    catch {
+                        // Namespace might already be gone
+                        setStatus((s) => ({ ...s, namespace: "error" }));
+                    }
+                }
+                else {
+                    setStatus((s) => ({ ...s, namespace: "skipped" }));
+                }
+            }
+            else {
+                // Cluster not accessible - skip all cluster operations
+                setStatus((s) => ({
+                    ...s,
+                    helm: "skipped",
+                    pvc: "skipped",
+                    namespace: "skipped",
+                }));
+            }
+            // Destroy infrastructure if requested and it exists
+            if (cluster && deploymentScope.hasInfrastructure) {
+                setStatus((s) => ({ ...s, infrastructure: "running" }));
+                try {
+                    await terraformDestroy(name);
+                    setStatus((s) => ({ ...s, infrastructure: "success" }));
+                }
+                catch {
+                    setStatus((s) => ({ ...s, infrastructure: "error" }));
+                }
+            }
+            else {
+                setStatus((s) => ({ ...s, infrastructure: "skipped" }));
+            }
+            // Clean up local files (only if --config flag is passed)
+            if (config && deploymentScope.hasLocalFiles) {
+                setStatus((s) => ({ ...s, cleanup: "running" }));
+                try {
+                    await deleteDeployment(name);
+                    setStatus((s) => ({ ...s, cleanup: "success" }));
+                }
+                catch {
+                    setStatus((s) => ({ ...s, cleanup: "error" }));
+                }
+            }
+            else {
+                setStatus((s) => ({ ...s, cleanup: "skipped" }));
+            }
+            setStep("complete");
+            setTimeout(() => exit(), 3000);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : "Destruction failed");
+            setStep("error");
+        }
+    }, [name, cluster, exit]);
+    // Loading screen
+    if (step === "loading") {
+        return (_jsx(BorderBox, { title: `Destroying ${name}`, children: _jsx(Box, { flexDirection: "column", marginY: 1, children: _jsx(Spinner, { label: "Checking deployment state..." }) }) }));
+    }
+    // Error screen
+    if (step === "error") {
+        return (_jsx(BorderBox, { title: "Destruction 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: _jsx(Text, { color: colors.muted, dimColor: true, children: "Press Enter or Esc to exit" }) })] }) }));
+    }
+    // Complete screen
+    if (step === "complete") {
+        const cleanedItems = [];
+        if (status.helm === "success")
+            cleanedItems.push("Helm release");
+        if (status.pvc === "success")
+            cleanedItems.push("Persistent volume claims");
+        if (status.namespace === "success")
+            cleanedItems.push("Kubernetes namespace");
+        if (status.infrastructure === "success")
+            cleanedItems.push("Cloud infrastructure");
+        if (status.cleanup === "success")
+            cleanedItems.push("Local configuration files");
+        // Check if nothing was cleaned in cluster (no helm, no pvc, no namespace)
+        const noClusterCleanup = status.helm === "skipped" &&
+            status.pvc === "skipped" &&
+            status.namespace === "skipped";
+        return (_jsx(BorderBox, { title: "Destruction Complete", children: _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsxs(Text, { color: colors.success, bold: true, children: ["\u2713 Deployment \"", name, "\" has been destroyed"] }), cleanedItems.length > 0 && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: colors.muted, children: "Cleaned up:" }), cleanedItems.map((item) => (_jsxs(Text, { color: colors.muted, children: [" ", "\u2022 ", item] }, item)))] })), noClusterCleanup && status.cleanup === "success" && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: colors.muted, dimColor: true, children: "Note: No cluster resources found, only local files were cleaned up." }) })), status.cleanup === "skipped" && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: colors.muted, dimColor: true, children: ["Local configuration files preserved in ~/.rulebricks/deployments/", name, "/"] }) }))] }) }));
+    }
+    // Destroying screen
+    if (step === "destroying") {
+        // Show cluster operations if cluster is accessible
+        const showClusterOps = scope?.clusterAccessible;
+        const showInfra = cluster && scope?.hasInfrastructure;
+        return (_jsx(BorderBox, { title: `Destroying ${name}`, children: _jsxs(Box, { flexDirection: "column", marginY: 1, children: [showClusterOps && (_jsxs(_Fragment, { children: [_jsx(StatusLine, { status: status.helm, label: "Uninstalling Helm release" }), _jsx(StatusLine, { status: status.pvc, label: "Deleting persistent volumes" }), _jsx(StatusLine, { status: status.namespace, label: "Deleting namespace" })] })), showInfra && (_jsx(StatusLine, { status: status.infrastructure, label: "Destroying infrastructure" })), config && (_jsx(StatusLine, { status: status.cleanup, label: "Cleaning up local files" })), !scope?.clusterAccessible && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: colors.warning, dimColor: true, children: "Skipping cluster operations (cluster not accessible)" }) })), _jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: "Destroying deployment..." }) })] }) }));
+    }
+    // Confirmation screen
+    // Check if there's nothing in the cluster to clean up
+    const hasClusterResources = scope?.hasHelmRelease || scope?.hasNamespace;
+    const onlyLocalFiles = !hasClusterResources && !scope?.hasInfrastructure;
+    const needsInfraConfirm = cluster && scope?.hasInfrastructure;
+    const willDeleteConfig = config && scope?.hasLocalFiles;
+    // Nothing to do if only local files exist but --config not passed
+    if (onlyLocalFiles && !config) {
+        return (_jsx(BorderBox, { title: "Nothing to Destroy", children: _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Text, { color: colors.muted, children: "No cluster resources found to clean up." }), _jsx(Text, { color: colors.muted, children: "Local configuration files will be preserved." }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: colors.muted, dimColor: true, children: ["Use ", _jsx(Text, { color: colors.accent, children: "--config" }), " to also remove local files."] }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: colors.muted, dimColor: true, children: "Press Esc to exit" }) })] }) }));
+    }
+    return (_jsx(BorderBox, { title: "Confirm Destruction", children: _jsx(Box, { flexDirection: "column", marginY: 1, children: onlyLocalFiles && config ? (
+            // Only cleaning local files (with --config)
+            _jsxs(_Fragment, { children: [_jsx(Text, { color: colors.warning, bold: true, children: "\u2139 Local Cleanup" }), _jsxs(Box, { marginY: 1, flexDirection: "column", children: [_jsx(Text, { children: "No cluster resources found to clean up." }), _jsx(Text, { children: "This will delete local configuration files." })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: colors.warning, children: "Press Enter to confirm, Esc to cancel" }) })] })) : (
+            // Full destruction
+            _jsxs(_Fragment, { children: [_jsx(Text, { color: colors.accent, bold: true, children: "\u26A0 WARNING" }), _jsxs(Box, { marginY: 1, flexDirection: "column", children: [_jsx(Text, { color: colors.muted, children: "This will permanently delete:" }), (scope?.hasHelmRelease || scope?.hasNamespace) && (_jsxs(_Fragment, { children: [_jsx(Text, { color: colors.muted, children: " \u2022 Rulebricks application" }), _jsxs(Text, { color: colors.muted, children: [" ", "\u2022 All databases and stored data"] }), _jsx(Text, { color: colors.muted, children: " \u2022 All persistent volumes" }), _jsx(Text, { color: colors.muted, children: " \u2022 Monitoring stack" }), _jsx(Text, { color: colors.muted, children: " \u2022 Kubernetes namespace" })] })), needsInfraConfirm && (_jsxs(_Fragment, { children: [_jsx(Text, { color: colors.accent, children: " \u2022 Kubernetes cluster" }), _jsx(Text, { color: colors.accent, children: " \u2022 All cloud infrastructure" })] })), willDeleteConfig && (_jsx(Text, { color: colors.muted, children: " \u2022 Local configuration files" })), !needsInfraConfirm && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: colors.muted, dimColor: true, children: "Cloud infrastructure will be preserved. Use --cluster to remove it." }) })), !willDeleteConfig && (_jsx(Box, { marginTop: !needsInfraConfirm ? 0 : 1, children: _jsx(Text, { color: colors.muted, dimColor: true, children: "Local config files will be preserved. Use --config to remove them." }) })), !scope?.clusterAccessible && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: colors.warning, dimColor: true, children: "\u26A0 Cluster is not accessible. Cluster resources may need manual cleanup." }) }))] }), needsInfraConfirm ? (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["Type", " ", _jsx(Text, { color: colors.accent, bold: true, children: "destroy-all" }), " ", "to confirm:"] }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: colors.accent, children: "\u276F " }), _jsx(Text, { children: confirmText }), _jsx(Text, { color: colors.muted, children: "\u2588" })] })] })) : (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: colors.warning, children: "Press Enter to confirm, Esc to cancel" }) }))] })) }) }));
+}
+export function DestroyCommand(props) {
+    return (_jsxs(ThemeProvider, { theme: "destroy", children: [_jsx(Logo, {}), _jsx(DestroyCommandInner, { ...props })] }));
+}
+/**
+ * Determines what actually exists by checking cluster state directly.
+ * This ensures cleanup works even if local state is out of sync.
+ */
+async function determineScope(name, config, state) {
+    // Check if we have local files (we do, since we loaded the deployment)
+    const hasLocalFiles = true;
+    // Check if infrastructure was provisioned (from local terraform state)
+    const hasInfrastructure = await hasTerraformState(name);
+    // Use namespace from state if available (backwards compat), otherwise compute from deployment name
+    const namespace = state?.application?.namespace || getNamespace(name);
+    const releaseName = getReleaseName(name);
+    // Check if cluster is accessible
+    let clusterAccessible = false;
+    try {
+        clusterAccessible = await isClusterAccessible();
+    }
+    catch {
+        clusterAccessible = false;
+    }
+    // If cluster is accessible, check what actually exists in the cluster
+    let hasHelmRelease = false;
+    let hasNamespace = false;
+    if (clusterAccessible) {
+        // Check if Helm release actually exists in the cluster
+        try {
+            const installedVersion = await getInstalledVersion(releaseName, namespace);
+            hasHelmRelease = installedVersion !== null;
+        }
+        catch {
+            hasHelmRelease = false;
+        }
+        // Check if namespace exists
+        try {
+            hasNamespace = await namespaceExists(namespace);
+        }
+        catch {
+            hasNamespace = false;
+        }
+    }
+    return {
+        hasLocalFiles,
+        hasHelmRelease,
+        hasNamespace,
+        hasInfrastructure,
+        clusterAccessible,
+    };
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,7 @@
+import { ProfileConfig } from "../types/index.js";
+interface InitWizardProps {
+    initialName?: string;
+    profile?: ProfileConfig | null;
+}
+export declare function InitWizard({ initialName, profile: providedProfile, }: InitWizardProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/commands/init.js

@@ -0,0 +1,201 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useCallback, useEffect } from "react";
+import { Box, Text, useApp, useStdout } from "ink";
+import { WizardProvider, useWizard, } from "../components/Wizard/WizardContext.js";
+import { DeploymentModeStep, CloudProviderStep, DomainStep, SMTPStep, DatabaseStep, SupabaseCredentialsStep, TierStep, FeaturesStep, FeatureConfigStep, VersionStep, ReviewStep, } from "../components/Wizard/steps/index.js";
+import { AppShell, ProgressHeader, ThemeProvider, useTheme, Logo, LOGO_LINES, } from "../components/common/index.js";
+import { saveDeploymentConfig, deploymentExists, loadProfile, updateProfile, extractProfileFromConfig, } from "../lib/config.js";
+import { generateHelmValues } from "../lib/helmValues.js";
+const STEP_INFO = {
+    mode: { title: "Deployment Mode", description: "Choose how to deploy" },
+    cloud: { title: "Cloud Provider", description: "Select your cloud provider" },
+    domain: { title: "Domain & Email", description: "Configure your domain" },
+    smtp: { title: "Email (SMTP)", description: "Configure email delivery" },
+    database: { title: "Database", description: "Choose your database setup" },
+    "database-creds": {
+        title: "Database Credentials",
+        description: "Configure database access",
+    },
+    tier: {
+        title: "Performance Tier",
+        description: "Select your deployment size",
+    },
+    features: {
+        title: "Optional Features",
+        description: "Enable additional features",
+    },
+    "feature-config": {
+        title: "Feature Settings",
+        description: "Configure enabled features",
+    },
+    version: {
+        title: "License & Version",
+        description: "Enter license and select version",
+    },
+    review: { title: "Review & Save", description: "Review your configuration" },
+};
+function WizardStepController({ onSaveComplete }) {
+    const { state, dispatch, toConfig } = useWizard();
+    const { exit } = useApp();
+    const { write } = useStdout();
+    const { colors } = useTheme();
+    const [currentStep, setCurrentStep] = useState("mode");
+    const [saving, setSaving] = useState(false);
+    const [complete, setComplete] = useState(false);
+    const [error, setError] = useState(null);
+    // Clear terminal when transitioning to completion screen
+    useEffect(() => {
+        if (complete) {
+            // Clear terminal using ANSI escape codes
+            write("\x1B[2J\x1B[0;0H");
+        }
+    }, [complete, write]);
+    // Track pending navigation to handle React's async state updates
+    const [pendingNav, setPendingNav] = useState(null);
+    // Get list of active steps based on config
+    const getActiveSteps = useCallback(() => {
+        const steps = ["mode"];
+        // Cloud provider step for both provision and existing modes
+        if (state.infrastructureMode === "provision" ||
+            state.infrastructureMode === "existing") {
+            steps.push("cloud");
+        }
+        steps.push("domain", "smtp", "database");
+        // Database credentials only for self-hosted
+        if (state.databaseType === "self-hosted") {
+            steps.push("database-creds");
+        }
+        steps.push("tier", "features");
+        // Feature config only if AI, SSO, monitoring, external logging, or custom emails enabled
+        if (state.aiEnabled ||
+            state.ssoEnabled ||
+            state.monitoringEnabled ||
+            state.loggingSink !== "console" ||
+            state.customEmailsEnabled) {
+            steps.push("feature-config");
+        }
+        steps.push("version", "review");
+        return steps;
+    }, [
+        state.infrastructureMode,
+        state.databaseType,
+        state.aiEnabled,
+        state.ssoEnabled,
+        state.monitoringEnabled,
+        state.loggingSink,
+        state.customEmailsEnabled,
+    ]);
+    // Handle navigation after state updates - this ensures getActiveSteps has the latest state
+    useEffect(() => {
+        if (pendingNav) {
+            const steps = getActiveSteps();
+            const currentIndex = steps.indexOf(currentStep);
+            if (pendingNav === "next" && currentIndex < steps.length - 1) {
+                setCurrentStep(steps[currentIndex + 1]);
+            }
+            else if (pendingNav === "back" && currentIndex > 0) {
+                setCurrentStep(steps[currentIndex - 1]);
+            }
+            setPendingNav(null);
+        }
+    }, [pendingNav, currentStep, getActiveSteps]);
+    // Request navigation - will be processed after React renders with updated state
+    const goNext = useCallback(() => {
+        setPendingNav("next");
+    }, []);
+    const goBack = useCallback(() => {
+        setPendingNav("back");
+    }, []);
+    const handleSave = useCallback(async () => {
+        const config = toConfig();
+        if (!config) {
+            setError("Invalid configuration - please check all required fields");
+            return;
+        }
+        setSaving(true);
+        try {
+            if (await deploymentExists(config.name)) {
+                setError(`Deployment "${config.name}" already exists. Choose a different name.`);
+                setSaving(false);
+                return;
+            }
+            await saveDeploymentConfig(config);
+            await generateHelmValues(config);
+            // Save configuration values to profile for future deployments
+            const profileData = extractProfileFromConfig(config);
+            await updateProfile(profileData);
+            setComplete(true);
+            onSaveComplete?.();
+            setTimeout(() => exit(), 4000);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : "Failed to save configuration");
+            setSaving(false);
+        }
+    }, [toConfig, exit, onSaveComplete]);
+    // Get step progress
+    const steps = getActiveSteps();
+    const stepNumber = steps.indexOf(currentStep) + 1;
+    const totalSteps = steps.length;
+    const stepInfo = STEP_INFO[currentStep];
+    // Completion screen
+    if (complete) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { flexDirection: "column", marginTop: 1, marginBottom: 2, children: LOGO_LINES.map((line, i) => (_jsx(Text, { color: colors.accent, children: line }, i))) }), _jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: colors.success, bold: true, children: "\u2713 Configuration saved successfully!" }) }), _jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { children: ["Deployment name:", " ", _jsx(Text, { color: colors.accent, bold: true, children: state.name })] }), _jsxs(Text, { color: colors.muted, children: ["Configuration stored in ~/.rulebricks/deployments/", state.name, "/"] })] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Next steps:" }), _jsxs(Box, { marginLeft: 2, flexDirection: "column", children: [_jsxs(Text, { color: colors.muted, children: ["1. Run", " ", _jsxs(Text, { color: colors.accent, children: ["rulebricks deploy ", state.name] }), " ", "to deploy"] }), _jsx(Text, { color: colors.muted, children: "2. Configure your DNS records when prompted" }), _jsxs(Text, { color: colors.muted, children: ["3. Access Rulebricks at", " ", _jsxs(Text, { color: colors.accent, children: ["https://", state.domain] })] })] })] }), _jsx(Box, { marginTop: 2, children: _jsx(Text, { color: colors.muted, dimColor: true, children: "Exiting in a moment..." }) })] })] }));
+    }
+    // Saving state - simple, without wrapper
+    if (saving) {
+        return (_jsx(Box, { flexDirection: "column", paddingTop: 1, paddingLeft: 2, children: _jsx(Text, { color: colors.accent, children: "\u29D7 Saving configuration..." }) }));
+    }
+    // Error state - simple, without wrapper
+    if (error) {
+        return (_jsxs(Box, { flexDirection: "column", paddingTop: 1, paddingLeft: 2, children: [_jsx(Text, { color: colors.error, bold: true, children: "\u2717 Error" }), _jsx(Text, { color: colors.error, children: error }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: colors.muted, children: "Press Ctrl+C to exit and try again" }) })] }));
+    }
+    // Render current step
+    const renderStep = () => {
+        switch (currentStep) {
+            case "mode":
+                return _jsx(DeploymentModeStep, { onComplete: goNext });
+            case "cloud":
+                return _jsx(CloudProviderStep, { onComplete: goNext, onBack: goBack });
+            case "domain":
+                return _jsx(DomainStep, { onComplete: goNext, onBack: goBack });
+            case "smtp":
+                return _jsx(SMTPStep, { onComplete: goNext, onBack: goBack });
+            case "database":
+                return _jsx(DatabaseStep, { onComplete: goNext, onBack: goBack });
+            case "database-creds":
+                return _jsx(SupabaseCredentialsStep, { onComplete: goNext, onBack: goBack });
+            case "tier":
+                return _jsx(TierStep, { onComplete: goNext, onBack: goBack });
+            case "features":
+                return _jsx(FeaturesStep, { onComplete: goNext, onBack: goBack });
+            case "feature-config":
+                return _jsx(FeatureConfigStep, { onComplete: goNext, onBack: goBack });
+            case "version":
+                return _jsx(VersionStep, { onComplete: goNext, onBack: goBack });
+            case "review":
+                return _jsx(ReviewStep, { onComplete: handleSave, onBack: goBack });
+            default:
+                return null;
+        }
+    };
+    return (_jsxs(AppShell, { title: "Rulebricks Configuration", children: [_jsx(ProgressHeader, { currentStep: stepNumber, totalSteps: totalSteps, stepTitle: stepInfo?.title || "Complete" }), _jsx(Box, { marginTop: 1, children: renderStep() })] }));
+}
+export function InitWizard({ initialName, profile: providedProfile, }) {
+    const [profile, setProfile] = useState(providedProfile ?? null);
+    const [profileLoaded, setProfileLoaded] = useState(!!providedProfile);
+    // Load profile on mount if not provided
+    useEffect(() => {
+        if (!providedProfile) {
+            loadProfile().then((loaded) => {
+                setProfile(loaded);
+                setProfileLoaded(true);
+            });
+        }
+    }, [providedProfile]);
+    // Show loading state while profile is being loaded
+    if (!profileLoaded) {
+        return (_jsxs(ThemeProvider, { theme: "init", children: [_jsx(Logo, {}), _jsx(Box, { paddingLeft: 2, children: _jsx(Text, { children: "Loading..." }) })] }));
+    }
+    return (_jsxs(ThemeProvider, { theme: "init", children: [_jsx(Logo, {}), _jsx(WizardProvider, { initialName: initialName, profile: profile, children: _jsx(WizardStepController, {}) })] }));
+}

package/dist/commands/logs.d.ts

@@ -0,0 +1,9 @@
+interface LogsCommandProps {
+    name: string;
+    component: string;
+    follow?: boolean;
+    tail?: number;
+    split?: boolean;
+}
+export declare function LogsCommand(props: LogsCommandProps): import("react/jsx-runtime").JSX.Element;
+export {};