@rulebricks/cli 2.1.6 → 2.3.1

package/dist/commands/list.js

@@ -0,0 +1,74 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Box, Text, useApp } from "ink";
+import { BorderBox, Logo, Spinner, ThemeProvider, useTheme, } from "../components/common/index.js";
+import { listDeployments } from "../lib/config.js";
+import { loadDeploymentHealth, } from "../lib/deploymentHealth.js";
+function statusText(health) {
+    switch (health.kind) {
+        case "online":
+            return { icon: "●", label: "online", color: "green" };
+        case "installed-unreachable":
+            return { icon: "◐", label: "installed, URL unreachable", color: "yellow" };
+        case "installed-degraded":
+            return { icon: "◐", label: "installed, pods not ready", color: "yellow" };
+        case "cluster-unreachable":
+            return { icon: "?", label: "cluster unreachable", color: "yellow" };
+        case "destroyed":
+            return { icon: "○", label: "destroyed", color: "gray" };
+        case "not-installed":
+            return { icon: "○", label: "not installed", color: "gray" };
+        case "config-error":
+            return { icon: "✗", label: "config error", color: "red" };
+    }
+}
+function ListCommandInner() {
+    const { exit } = useApp();
+    const { colors } = useTheme();
+    const [step, setStep] = useState("loading");
+    const [loadingLabel, setLoadingLabel] = useState("Loading deployments...");
+    const [deployments, setDeployments] = useState([]);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        (async () => {
+            try {
+                const names = await listDeployments();
+                if (names.length === 0) {
+                    setStep("empty");
+                    setTimeout(() => exit(), 250);
+                    return;
+                }
+                setLoadingLabel(`Checking health for ${names.length} deployment(s)...`);
+                const results = [];
+                for (const name of names) {
+                    setLoadingLabel(`Checking ${name}...`);
+                    results.push(await loadDeploymentHealth(name));
+                }
+                setDeployments(results);
+                setStep("complete");
+                setTimeout(() => exit(), 250);
+            }
+            catch (err) {
+                setError(err instanceof Error ? err.message : "Failed to list deployments");
+                setStep("error");
+                setTimeout(() => exit(), 1000);
+            }
+        })();
+    }, [exit]);
+    if (step === "loading") {
+        return (_jsx(BorderBox, { title: "Deployments", children: _jsx(Box, { marginY: 1, children: _jsx(Spinner, { label: loadingLabel }) }) }));
+    }
+    if (step === "empty") {
+        return (_jsx(BorderBox, { title: "Deployments", children: _jsx(Box, { marginY: 1, children: _jsx(Text, { color: colors.warning, children: "No deployments found. Run \"rulebricks init\" to create one." }) }) }));
+    }
+    if (step === "error") {
+        return (_jsx(BorderBox, { title: "List 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 })] }) }));
+    }
+    return (_jsx(BorderBox, { title: "Deployments", children: _jsx(Box, { flexDirection: "column", marginY: 1, children: deployments.map((deployment) => {
+                const status = statusText(deployment);
+                return (_jsxs(Box, { children: [_jsx(Text, { color: status.color, children: status.icon }), _jsxs(Text, { children: [" ", deployment.name, " "] }), _jsx(Text, { color: status.color, children: status.label }), deployment.url && (_jsxs(Text, { color: colors.muted, children: [" ", deployment.url] }))] }, deployment.name));
+            }) }) }));
+}
+export function ListCommand() {
+    return (_jsxs(ThemeProvider, { theme: "status", children: [_jsx(Logo, {}), _jsx(ListCommandInner, {})] }));
+}

package/dist/commands/open.d.ts

@@ -1,4 +1,4 @@
-type OpenTarget = "all" | "config" | "values" | "terraform";
+type OpenTarget = "all" | "config" | "values";
 interface OpenCommandProps {
     name: string;
     target: OpenTarget;

package/dist/commands/open.js

@@ -5,7 +5,7 @@ import { spawn } from "child_process";
 import path from "path";
 import { promises as fs } from "fs";
 import { BorderBox, Spinner, ThemeProvider, useTheme, Logo, } from "../components/common/index.js";
-import { deploymentExists, getDeploymentDir, getTerraformDir, getHelmValuesPath, } from "../lib/config.js";
+import { deploymentExists, getDeploymentDir, getHelmValuesPath, } from "../lib/config.js";
 /**
  * Resolves the appropriate command to open files/directories based on OS and environment
  */
@@ -72,9 +72,6 @@ function OpenCommandInner({ name, target }) {
                     case "values":
                         targetPath = getHelmValuesPath(name);
                         break;
-                    case "terraform":
-                        targetPath = getTerraformDir(name);
-                        break;
                     case "all":
                     default:
                         targetPath = deployDir;
@@ -85,10 +82,7 @@ function OpenCommandInner({ name, target }) {
                     await fs.access(targetPath);
                 }
                 catch {
-                    if (target === "terraform") {
-                        setError(`Terraform directory not found. Run "rulebricks deploy ${name}" first to create infrastructure files.`);
-                    }
-                    else if (target === "values") {
+                    if (target === "values") {
                         setError(`values.yaml not found. Run "rulebricks init" or "rulebricks deploy ${name}" first.`);
                     }
                     else {
@@ -129,10 +123,8 @@ function OpenCommandInner({ name, target }) {
         ? "deployment directory"
         : target === "config"
             ? "config.yaml"
-            : target === "values"
-                ? "values.yaml"
-                : "terraform directory";
-    return (_jsx(BorderBox, { title: "Opened", children: _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsxs(Text, { color: colors.success, bold: true, children: ["\u2713 Opened ", targetLabel] }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: colors.muted, dimColor: true, children: ["Path: ", openedPath] }) }), target === "all" && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: colors.muted, children: "Available files:" }), _jsxs(Text, { color: colors.muted, children: [" ", "\u2022 config.yaml - Deployment configuration"] }), _jsx(Text, { color: colors.muted, children: " \u2022 values.yaml - Helm chart values" }), _jsxs(Text, { color: colors.muted, children: [" ", "\u2022 terraform/ - Infrastructure files"] })] })), (target === "values" || target === "config") && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: colors.warning, dimColor: true, children: "Note: Manual edits may desync from wizard-managed settings" }) }))] }) }));
+            : "values.yaml";
+    return (_jsx(BorderBox, { title: "Opened", children: _jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsxs(Text, { color: colors.success, bold: true, children: ["\u2713 Opened ", targetLabel] }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: colors.muted, dimColor: true, children: ["Path: ", openedPath] }) }), target === "all" && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: colors.muted, children: "Available files:" }), _jsxs(Text, { color: colors.muted, children: [" ", "\u2022 config.yaml - Deployment configuration"] }), _jsx(Text, { color: colors.muted, children: " \u2022 values.yaml - Helm chart values" })] })), (target === "values" || target === "config") && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: colors.warning, dimColor: true, children: "Note: Manual edits may desync from wizard-managed settings" }) }))] }) }));
 }
 export function OpenCommand(props) {
     return (_jsxs(ThemeProvider, { theme: "status", children: [_jsx(Logo, {}), _jsx(OpenCommandInner, { ...props })] }));

package/dist/commands/redeploy.d.ts

@@ -0,0 +1,6 @@
+interface RedeployCommandProps {
+    name: string;
+    chartVersion?: string;
+}
+export declare function RedeployCommand(props: RedeployCommandProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/commands/redeploy.js

@@ -0,0 +1,310 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Box, Text } from "ink";
+import { BorderBox, Logo, Spinner, ThemeProvider, useTheme, } from "../components/common/index.js";
+import { InitWizard } from "./init.js";
+import { DeployCommand } from "./deploy.js";
+import { configToWizardState, } from "../components/Wizard/WizardContext.js";
+import { loadHelmValues, loadProfile, } from "../lib/config.js";
+import { loadDeploymentHealth } from "../lib/deploymentHealth.js";
+import { getInstalledChartVersion } from "../lib/helm.js";
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === "string" && value ? value : undefined;
+}
+function numberValue(value) {
+    return typeof value === "number" ? value : undefined;
+}
+function booleanValue(value) {
+    return typeof value === "boolean" ? value : undefined;
+}
+function secretRefValue(value) {
+    if (!isRecord(value))
+        return undefined;
+    const name = stringValue(value.name);
+    const key = stringValue(value.key);
+    return name && key ? { name, key } : undefined;
+}
+function applyHelmValuesToConfig(config, values) {
+    const next = JSON.parse(JSON.stringify(config));
+    if (!values)
+        return next;
+    const global = isRecord(values.global) ? values.global : null;
+    if (global) {
+        next.domain = stringValue(global.domain) ?? next.domain;
+        next.adminEmail = stringValue(global.email) ?? next.adminEmail;
+        next.licenseKey = stringValue(global.licenseKey) ?? next.licenseKey;
+        next.version = stringValue(global.version) ?? next.version;
+        if (isRecord(global.smtp)) {
+            next.smtp = {
+                ...next.smtp,
+                host: stringValue(global.smtp.host) ?? next.smtp.host,
+                port: numberValue(global.smtp.port) ?? next.smtp.port,
+                user: stringValue(global.smtp.user) ?? next.smtp.user,
+                pass: stringValue(global.smtp.pass) ?? next.smtp.pass,
+                from: stringValue(global.smtp.from) ?? next.smtp.from,
+                fromName: stringValue(global.smtp.fromName) ?? next.smtp.fromName,
+            };
+        }
+        if (isRecord(global.supabase)) {
+            if (next.database.type === "supabase-cloud") {
+                next.database.supabaseUrl =
+                    stringValue(global.supabase.url) ?? next.database.supabaseUrl;
+                next.database.supabaseAnonKey =
+                    stringValue(global.supabase.anonKey) ??
+                        next.database.supabaseAnonKey;
+                next.database.supabaseServiceKey =
+                    stringValue(global.supabase.serviceKey) ??
+                        next.database.supabaseServiceKey;
+                next.database.supabaseAccessToken =
+                    stringValue(global.supabase.accessToken) ??
+                        next.database.supabaseAccessToken;
+                next.database.supabaseProjectRef =
+                    stringValue(global.supabase.projectRef) ??
+                        next.database.supabaseProjectRef;
+            }
+            else {
+                next.database.supabaseJwtSecret =
+                    stringValue(global.supabase.jwtSecret) ??
+                        next.database.supabaseJwtSecret;
+            }
+        }
+        if (isRecord(global.ai)) {
+            next.features.ai.enabled =
+                booleanValue(global.ai.enabled) ?? next.features.ai.enabled;
+            next.features.ai.openaiApiKey =
+                stringValue(global.ai.openaiApiKey) ??
+                    next.features.ai.openaiApiKey;
+        }
+        if (isRecord(global.sso)) {
+            next.features.sso.enabled =
+                booleanValue(global.sso.enabled) ?? next.features.sso.enabled;
+            next.features.sso.provider =
+                stringValue(global.sso.provider) ??
+                    next.features.sso.provider;
+            next.features.sso.url =
+                stringValue(global.sso.url) ?? next.features.sso.url;
+            next.features.sso.clientId =
+                stringValue(global.sso.clientId) ?? next.features.sso.clientId;
+            next.features.sso.clientSecret =
+                stringValue(global.sso.clientSecret) ??
+                    next.features.sso.clientSecret;
+        }
+        if (isRecord(global.storage) && next.storage) {
+            const storage = global.storage;
+            next.storage.provider =
+                stringValue(storage.provider) ??
+                    next.storage.provider;
+            next.storage.bucket =
+                stringValue(storage.bucket) ?? next.storage.bucket;
+            next.storage.region =
+                stringValue(storage.region) ?? next.storage.region;
+            if (isRecord(storage.s3)) {
+                next.storage.awsIamRoleArn =
+                    stringValue(storage.s3.iamRoleArn) ?? next.storage.awsIamRoleArn;
+            }
+            if (isRecord(storage.azure)) {
+                next.storage.cloudAuthMode =
+                    storage.azure.authMode === "connection-string"
+                        ? "secret"
+                        : next.storage.cloudAuthMode;
+                next.storage.azureBlobClientId =
+                    stringValue(storage.azure.clientId) ??
+                        next.storage.azureBlobClientId;
+                next.storage.azureBlobTenantId =
+                    stringValue(storage.azure.tenantId) ??
+                        next.storage.azureBlobTenantId;
+                next.storage.azureBlobContainer =
+                    stringValue(storage.azure.container) ??
+                        next.storage.azureBlobContainer;
+                next.storage.azureBlobConnectionStringSecretRef =
+                    secretRefValue(storage.azure.connectionStringSecretRef) ??
+                        next.storage.azureBlobConnectionStringSecretRef;
+            }
+            if (isRecord(storage.gcp)) {
+                next.storage.gcpServiceAccountEmail =
+                    stringValue(storage.gcp.serviceAccountEmail) ??
+                        next.storage.gcpServiceAccountEmail;
+            }
+            if (isRecord(storage.paths)) {
+                next.storage.paths = {
+                    decisionLogs: stringValue(storage.paths.decisionLogs) ??
+                        next.storage.paths?.decisionLogs,
+                    dbBackups: stringValue(storage.paths.dbBackups) ??
+                        next.storage.paths?.dbBackups,
+                };
+            }
+        }
+    }
+    if (isRecord(values.clusterIssuer)) {
+        next.tlsEmail = stringValue(values.clusterIssuer.email) ?? next.tlsEmail;
+    }
+    if (isRecord(values.backup)) {
+        next.backup = {
+            enabled: booleanValue(values.backup.enabled) ?? next.backup?.enabled ?? false,
+            schedule: stringValue(values.backup.schedule) ?? next.backup?.schedule ?? "0 2 * * *",
+            retentionDays: numberValue(values.backup.retentionDays) ??
+                next.backup?.retentionDays ??
+                7,
+        };
+    }
+    // External services (managed Redis/Kafka). The saved config is authoritative;
+    // here we reconcile mode + connection details from the live chart values so a
+    // redeploy reflects any drift. Preset/identity fall back to the saved config.
+    const rb = isRecord(values.rulebricks) ? values.rulebricks : null;
+    const redisLive = rb && isRecord(rb.redis) ? rb.redis : null;
+    if (redisLive) {
+        const redisEnabled = booleanValue(redisLive.enabled);
+        const savedRedis = next.externalServices?.redis;
+        if (redisEnabled === false) {
+            const ext = isRecord(redisLive.external) ? redisLive.external : {};
+            const tls = isRecord(ext.tls) ? booleanValue(ext.tls.enabled) : undefined;
+            const httpApiLive = isRecord(ext.httpApi) ? ext.httpApi : null;
+            next.externalServices = {
+                ...next.externalServices,
+                redis: {
+                    mode: "external",
+                    external: {
+                        ...(savedRedis?.external ?? {}),
+                        host: stringValue(ext.host) ?? savedRedis?.external?.host,
+                        port: numberValue(ext.port) ?? savedRedis?.external?.port,
+                        password: stringValue(ext.password) ?? savedRedis?.external?.password,
+                        existingSecret: stringValue(ext.existingSecret) ??
+                            savedRedis?.external?.existingSecret,
+                        existingSecretKey: stringValue(ext.existingSecretKey) ??
+                            savedRedis?.external?.existingSecretKey,
+                        tls: tls ?? savedRedis?.external?.tls,
+                        httpApi: httpApiLive
+                            ? {
+                                enabled: booleanValue(httpApiLive.enabled) ?? false,
+                                url: stringValue(httpApiLive.url),
+                                token: stringValue(httpApiLive.token),
+                            }
+                            : savedRedis?.external?.httpApi,
+                    },
+                },
+            };
+        }
+        else if (redisEnabled === true) {
+            next.externalServices = {
+                ...next.externalServices,
+                redis: { mode: "embedded" },
+            };
+        }
+    }
+    const kafkaEnabled = isRecord(values.kafka)
+        ? booleanValue(values.kafka.enabled)
+        : undefined;
+    const loggingLive = rb && isRecord(rb.app) && isRecord(rb.app.logging) ? rb.app.logging : null;
+    if (kafkaEnabled === false && loggingLive) {
+        const savedKafka = next.externalServices?.kafka;
+        const saslLive = isRecord(loggingLive.kafkaSasl)
+            ? loggingLive.kafkaSasl
+            : null;
+        const bridge = isRecord(values.kafkaBridge) ? values.kafkaBridge : null;
+        const mechanism = stringValue(saslLive?.mechanism) ?? savedKafka?.external?.sasl?.mechanism;
+        next.externalServices = {
+            ...next.externalServices,
+            kafka: {
+                mode: "external",
+                external: {
+                    ...(savedKafka?.external ?? {}),
+                    preset: savedKafka?.external?.preset ?? "custom",
+                    brokers: stringValue(loggingLive.kafkaBrokers) ??
+                        savedKafka?.external?.brokers,
+                    topic: stringValue(loggingLive.kafkaTopic) ??
+                        savedKafka?.external?.topic,
+                    topicPrefix: stringValue(loggingLive.kafkaTopicPrefix) ??
+                        savedKafka?.external?.topicPrefix,
+                    ssl: booleanValue(loggingLive.kafkaSsl) ?? savedKafka?.external?.ssl,
+                    sasl: mechanism
+                        ? {
+                            mechanism,
+                            region: stringValue(saslLive?.region) ??
+                                savedKafka?.external?.sasl?.region,
+                            username: stringValue(saslLive?.username) ??
+                                savedKafka?.external?.sasl?.username,
+                            password: stringValue(saslLive?.password) ??
+                                savedKafka?.external?.sasl?.password,
+                            existingSecret: stringValue(saslLive?.existingSecret) ??
+                                savedKafka?.external?.sasl?.existingSecret,
+                        }
+                        : savedKafka?.external?.sasl,
+                    identity: {
+                        ...(savedKafka?.external?.identity ?? {}),
+                        awsRoleArn: stringValue(bridge?.awsRoleArn) ||
+                            savedKafka?.external?.identity?.awsRoleArn,
+                    },
+                },
+            },
+        };
+    }
+    else if (kafkaEnabled === true) {
+        next.externalServices = {
+            ...next.externalServices,
+            kafka: { mode: "embedded" },
+        };
+    }
+    return next;
+}
+function RedeployCommandInner({ name, chartVersion }) {
+    const { colors } = useTheme();
+    const [step, setStep] = useState("loading");
+    const [error, setError] = useState(null);
+    const [wizardState, setWizardState] = useState(null);
+    const [profile, setProfile] = useState(null);
+    const [resolvedChartVersion, setResolvedChartVersion] = useState(chartVersion);
+    useEffect(() => {
+        (async () => {
+            try {
+                const health = await loadDeploymentHealth(name, {
+                    refreshKubeconfig: true,
+                });
+                if (!health.config) {
+                    setError(health.configError || `Deployment "${name}" is invalid.`);
+                    setStep("error");
+                    return;
+                }
+                if (health.kind !== "online") {
+                    setError(`Deployment "${name}" must be installed and reachable before redeploy. Current status: ${health.kind}.`);
+                    setStep("error");
+                    return;
+                }
+                const [loadedProfile, values] = await Promise.all([
+                    loadProfile(),
+                    loadHelmValues(name),
+                ]);
+                const hydratedConfig = applyHelmValuesToConfig(health.config, values);
+                const installedChartVersion = chartVersion ||
+                    (health.state?.application?.chartVersion !== "latest"
+                        ? health.state?.application?.chartVersion
+                        : undefined) ||
+                    (await getInstalledChartVersion(health.releaseName, health.namespace)) ||
+                    undefined;
+                setProfile(loadedProfile);
+                setResolvedChartVersion(installedChartVersion);
+                setWizardState(configToWizardState(hydratedConfig, loadedProfile));
+                setStep("wizard");
+            }
+            catch (err) {
+                setError(err instanceof Error ? err.message : "Failed to load redeploy");
+                setStep("error");
+            }
+        })();
+    }, [name, chartVersion]);
+    if (step === "deploy") {
+        return (_jsx(DeployCommand, { name: name, version: resolvedChartVersion, regenerateValues: false, assumeDnsConfigured: true }));
+    }
+    if (step === "wizard" && wizardState) {
+        return (_jsx(InitWizard, { initialState: wizardState, mode: "redeploy", profile: profile, onSaveComplete: () => setStep("deploy") }));
+    }
+    if (step === "error") {
+        return (_jsxs(ThemeProvider, { theme: "deploy", children: [_jsx(Logo, {}), _jsx(BorderBox, { title: "Redeploy 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 })] }) })] }));
+    }
+    return (_jsxs(ThemeProvider, { theme: "deploy", children: [_jsx(Logo, {}), _jsx(BorderBox, { title: "Redeploy", children: _jsx(Box, { marginY: 1, children: _jsx(Spinner, { label: "Checking deployment health..." }) }) })] }));
+}
+export function RedeployCommand(props) {
+    return _jsx(RedeployCommandInner, { ...props });
+}

package/dist/commands/restore.d.ts

@@ -0,0 +1,5 @@
+interface RestoreCommandProps {
+    name: string;
+}
+export declare function RestoreCommand(props: RestoreCommandProps): import("react/jsx-runtime").JSX.Element;
+export {};