@rulebricks/cli 2.1.7 → 2.3.2

package/dist/index.js

@@ -1,19 +1,26 @@
 #!/usr/bin/env node
 import { jsx as _jsx } from "react/jsx-runtime";
+import { createRequire } from "node:module";
 import { Command } from "commander";
 import { render } from "ink";
 import chalk from "chalk";
 import { InitWizard } from "./commands/init.js";
 import { DeployCommand } from "./commands/deploy.js";
+import { RedeployCommand } from "./commands/redeploy.js";
 import { UpgradeCommand } from "./commands/upgrade.js";
 import { DestroyCommand } from "./commands/destroy.js";
 import { StatusCommand } from "./commands/status.js";
+import { ListCommand } from "./commands/list.js";
 import { LogsCommand } from "./commands/logs.js";
 import { CloneCommand } from "./commands/clone.js";
 import { OpenCommand } from "./commands/open.js";
 import { BenchmarkCommand } from "./commands/benchmark.js";
+import { BackupCommand } from "./commands/backup.js";
+import { RestoreCommand } from "./commands/restore.js";
 import { listDeployments, deploymentExists } from "./lib/config.js";
-import packageJson from "../package.json" with { type: "json" };
+import { DeploymentPicker } from "./components/common/DeploymentPicker.js";
+const require = createRequire(import.meta.url);
+const packageJson = require("../package.json");
 const VERSION = packageJson.version;
 const program = new Command();
 program
@@ -41,15 +48,31 @@ program
     .command("deploy")
     .description("Deploy Rulebricks to your cluster")
     .argument("[name]", "Deployment name")
-    .option("--skip-infra", "Skip infrastructure provisioning")
-    .option("--version <version>", "Specific chart version to deploy")
+    .option("--chart-version <version>", "Specific chart version to deploy")
+    .option("--version <version>", "Deprecated alias for --chart-version")
+    .option("--inline-secrets", "Write secrets inline into values.yaml instead of creating Kubernetes Secrets (dev clusters only)")
     .action(async (name, options) => {
-    const deploymentName = name || (await selectDeployment());
+    const deploymentName = name || (await selectDeployment("deploy"));
     if (!deploymentName) {
-        console.error(chalk.red('No deployment specified. Run "rulebricks init" first.'));
+        console.error(chalk.red('No deployments found. Run "rulebricks init" first.'));
         process.exit(1);
     }
-    const { waitUntilExit } = render(_jsx(DeployCommand, { name: deploymentName, skipInfra: options.skipInfra, version: options.version }));
+    const { waitUntilExit } = render(_jsx(DeployCommand, { name: deploymentName, version: options.chartVersion || options.version, inlineSecrets: options.inlineSecrets }));
+    await waitUntilExit();
+});
+// Redeploy command
+program
+    .command("redeploy")
+    .description("Reconfigure and redeploy an existing Rulebricks deployment")
+    .argument("[name]", "Deployment name")
+    .option("--chart-version <version>", "Specific chart version to deploy")
+    .action(async (name, options) => {
+    const deploymentName = name || (await selectDeployment("redeploy"));
+    if (!deploymentName) {
+        console.error(chalk.red('No deployments found. Run "rulebricks init" first.'));
+        process.exit(1);
+    }
+    const { waitUntilExit } = render(_jsx(RedeployCommand, { name: deploymentName, chartVersion: options.chartVersion }));
     await waitUntilExit();
 });
 // Upgrade command
@@ -60,23 +83,10 @@ program
     .option("--version <version>", "Target version (defaults to latest)")
     .option("--dry-run", "Preview changes without applying")
     .action(async (name, options) => {
-    let deploymentName = name;
+    const deploymentName = name || (await selectDeployment("upgrade"));
     if (!deploymentName) {
-        const deployments = await listDeployments();
-        if (deployments.length === 0) {
-            console.error(chalk.red('No deployments found. Run "rulebricks init" first.'));
-            process.exit(1);
-        }
-        else if (deployments.length > 1) {
-            console.error(chalk.red("Please specify a deployment to upgrade.\n"));
-            console.log("Available deployments:");
-            for (const d of deployments) {
-                console.log(`  ${chalk.yellow("•")} ${d}`);
-            }
-            console.log(`\nUsage: ${chalk.cyan("rulebricks upgrade <name>")}`);
-            process.exit(1);
-        }
-        deploymentName = deployments[0]; // Only one deployment, auto-select
+        console.error(chalk.red('No deployments found. Run "rulebricks init" first.'));
+        process.exit(1);
     }
     const { waitUntilExit } = render(_jsx(UpgradeCommand, { name: deploymentName, targetVersion: options.version, dryRun: options.dryRun }));
     await waitUntilExit();
@@ -86,9 +96,9 @@ program
     .command("destroy")
     .description("Destroy a Rulebricks deployment")
     .argument("[name]", "Deployment name")
-    .option("--cluster", "Also destroy cloud infrastructure (EKS/GKE/AKS cluster)")
     .option("--config", "Also delete local configuration files")
     .option("-f, --force", "Skip confirmation")
+    .option("--purge", "Force removal of cluster-shared CRDs (cert-manager/keda/strimzi/prometheus); by default they're removed only when this is the last Rulebricks deployment on the cluster")
     .action(async (name, options) => {
     // For destroy, require explicit deployment name
     if (!name) {
@@ -106,7 +116,7 @@ program
         }
         process.exit(1);
     }
-    const { waitUntilExit } = render(_jsx(DestroyCommand, { name: name, cluster: options.cluster, config: options.config, force: options.force }));
+    const { waitUntilExit } = render(_jsx(DestroyCommand, { name: name, config: options.config, force: options.force, purge: options.purge }));
     await waitUntilExit();
 });
 // Status command
@@ -115,9 +125,9 @@ program
     .description("Show deployment status")
     .argument("[name]", "Deployment name")
     .action(async (name) => {
-    const deploymentName = name || (await selectDeployment());
+    const deploymentName = name || (await selectDeployment("show status for"));
     if (!deploymentName) {
-        console.error(chalk.red("No deployment specified."));
+        console.error(chalk.red('No deployments found. Run "rulebricks init" first.'));
         process.exit(1);
     }
     const { waitUntilExit } = render(_jsx(StatusCommand, { name: deploymentName }));
@@ -134,23 +144,10 @@ program
     .option("-t, --tail <lines>", "Number of lines to show", "100")
     .option("-s, --split", "Show logs in split-pane view (side-by-side columns)")
     .action(async (name, component, options) => {
-    let deploymentName = name;
+    const deploymentName = name || (await selectDeployment("view logs for"));
     if (!deploymentName) {
-        const deployments = await listDeployments();
-        if (deployments.length === 0) {
-            console.error(chalk.red('No deployments found. Run "rulebricks init" first.'));
-            process.exit(1);
-        }
-        else if (deployments.length > 1) {
-            console.error(chalk.red("Please specify a deployment to view logs for.\n"));
-            console.log("Available deployments:");
-            for (const d of deployments) {
-                console.log(`  ${chalk.yellow("•")} ${d}`);
-            }
-            console.log(`\nUsage: ${chalk.cyan("rulebricks logs <name> [component]")}`);
-            process.exit(1);
-        }
-        deploymentName = deployments[0]; // Only one deployment, auto-select
+        console.error(chalk.red('No deployments found. Run "rulebricks init" first.'));
+        process.exit(1);
     }
     const { waitUntilExit } = render(_jsx(LogsCommand, { name: deploymentName, component: component, follow: options.follow, tail: parseInt(options.tail, 10), split: options.split }));
     await waitUntilExit();
@@ -160,17 +157,8 @@ program
     .command("list")
     .description("List all deployments")
     .action(async () => {
-    const deployments = await listDeployments();
-    const listColor = chalk.green; // Use status theme color (green)
-    if (deployments.length === 0) {
-        console.log(chalk.yellow('No deployments found. Run "rulebricks init" to create one.'));
-        return;
-    }
-    console.log(chalk.bold("\nDeployments:\n"));
-    for (const name of deployments) {
-        console.log(`  ${listColor("•")} ${name}`);
-    }
-    console.log("");
+    const { waitUntilExit } = render(_jsx(ListCommand, {}));
+    await waitUntilExit();
 });
 // Clone command
 program
@@ -189,7 +177,6 @@ program
     .argument("<name>", "Deployment name")
     .option("--config", "Open config.yaml only")
     .option("--values", "Open values.yaml only")
-    .option("--terraform", "Open terraform directory only")
     .action(async (name, options) => {
     // Validate deployment exists before rendering
     const exists = await deploymentExists(name);
@@ -208,9 +195,7 @@ program
         ? "config"
         : options.values
             ? "values"
-            : options.terraform
-                ? "terraform"
-                : "all";
+            : "all";
     const { waitUntilExit } = render(_jsx(OpenCommand, { name: name, target: target }));
     await waitUntilExit();
 });
@@ -223,8 +208,41 @@ program
     const { waitUntilExit } = render(_jsx(BenchmarkCommand, { name: name }));
     await waitUntilExit();
 });
-// Helper to select a deployment interactively
-async function selectDeployment() {
+// Backup command
+program
+    .command("backup")
+    .description("Run an on-demand database backup")
+    .argument("[name]", "Deployment name")
+    .action(async (name) => {
+    const deploymentName = name || (await selectDeployment("back up"));
+    if (!deploymentName) {
+        console.error(chalk.red('No deployments found. Run "rulebricks init" first.'));
+        process.exit(1);
+    }
+    const { waitUntilExit } = render(_jsx(BackupCommand, { name: deploymentName }));
+    await waitUntilExit();
+});
+// Restore command
+program
+    .command("restore")
+    .description("Restore the database from a backup")
+    .argument("[name]", "Deployment name")
+    .action(async (name) => {
+    const deploymentName = name || (await selectDeployment("restore"));
+    if (!deploymentName) {
+        console.error(chalk.red('No deployments found. Run "rulebricks init" first.'));
+        process.exit(1);
+    }
+    const { waitUntilExit } = render(_jsx(RestoreCommand, { name: deploymentName }));
+    await waitUntilExit();
+});
+/**
+ * Resolves a deployment name when none was given on the command line.
+ * - 0 deployments: returns null (callers print the "run init first" error)
+ * - 1 deployment: auto-selects it
+ * - multiple: renders an interactive picker; Esc exits cleanly
+ */
+async function selectDeployment(action) {
     const deployments = await listDeployments();
     if (deployments.length === 0) {
         return null;
@@ -232,8 +250,22 @@ async function selectDeployment() {
     if (deployments.length === 1) {
         return deployments[0];
     }
-    // For now, return the first one. In a full implementation,
-    // we'd render an interactive selector
-    return deployments[0];
+    const selection = await new Promise((resolve) => {
+        const { unmount, clear } = render(_jsx(DeploymentPicker, { deployments: deployments, action: action, onSelect: (name) => {
+                clear();
+                unmount();
+                resolve(name);
+            }, onCancel: () => {
+                clear();
+                unmount();
+                resolve(null);
+            } }));
+    });
+    if (selection === null) {
+        // User cancelled the picker; not an error.
+        console.log(chalk.gray("Cancelled."));
+        process.exit(0);
+    }
+    return selection;
 }
 program.parse();

package/dist/lib/cloudCli.d.ts

@@ -2,7 +2,7 @@
  * Cloud CLI detection and dynamic resource listing
  *
  * Detects installed cloud CLIs (AWS, GCP, Azure), checks authentication status,
- * and provides functions to list regions and buckets dynamically.
+ * and provides functions to list regions, clusters, and storage dynamically.
  */
 import { CloudProvider } from "../types/index.js";
 /**
@@ -26,6 +26,41 @@ export interface AllCloudCliStatus {
     anyAvailable: boolean;
     anyInstalled: boolean;
 }
+/**
+ * Managed Kubernetes cluster discovered through a cloud provider CLI.
+ */
+export interface DiscoveredCluster {
+    provider: CloudProvider;
+    name: string;
+    region: string;
+    projectId?: string;
+    resourceGroup?: string;
+    status?: string;
+    version?: string;
+    nodeCount?: number;
+}
+/**
+ * AWS IAM role discovered through the AWS CLI.
+ */
+export interface IamRole {
+    name: string;
+    arn: string;
+}
+/**
+ * Azure user-assigned managed identity discovered through the Azure CLI.
+ */
+export interface AzureManagedIdentity {
+    name: string;
+    clientId: string;
+    resourceGroup?: string;
+}
+/**
+ * GCP service account discovered through the gcloud CLI.
+ */
+export interface GcpServiceAccount {
+    email: string;
+    displayName?: string;
+}
 /**
  * Check if AWS CLI is installed and authenticated
  */
@@ -42,27 +77,46 @@ export declare function listS3Buckets(): Promise<string[]>;
  * List EKS clusters in a specific region
  */
 export declare function listEksClusters(region: string): Promise<string[]>;
+export type AuroraLogicalReplication = "enabled" | "disabled" | "unknown";
+/**
+ * Best-effort preflight for an external AWS Aurora Postgres cluster: Supabase
+ * Realtime needs logical replication (wal_level=logical), which on Aurora is the
+ * STATIC cluster parameter rds.logical_replication - it lives in a custom DB
+ * cluster parameter group and needs a reboot, so bootstrap.sql can't set it and
+ * Realtime crashloops without it. Parses the cluster id + region from the writer
+ * endpoint and reads the attached parameter group. Fails OPEN ("unknown") on any
+ * ambiguity (non-Aurora host, denied describe, unexpected value) so it never
+ * blocks a deploy spuriously.
+ */
+export declare function checkAuroraLogicalReplication(host: string, fallbackRegion?: string): Promise<{
+    status: AuroraLogicalReplication;
+    parameterGroup?: string;
+}>;
 /**
- * Check if gcloud CLI is installed and fully authenticated
- *
- * For GCP to be considered "authenticated", the user must have:
- * 1. Logged in with `gcloud auth login`
- * 2. Set a default project with `gcloud config set project PROJECT_ID`
- * 3. Configured Application Default Credentials with `gcloud auth application-default login`
+ * List EKS clusters across all accessible AWS regions.
+ */
+export declare function listAllEksClusters(): Promise<DiscoveredCluster[]>;
+/**
+ * Discover active EKS clusters in one region.
+ */
+export declare function discoverEksClustersInRegion(region: string): Promise<DiscoveredCluster[]>;
+/**
+ * List IAM roles for selection (e.g. IRSA roles for S3 / AMP). Returns an empty
+ * list on any failure so callers can fall back to manual entry.
+ */
+export declare function listIamRoles(): Promise<IamRole[]>;
+/**
+ * Get the active AWS account ID (useful for constructing/validating ARNs).
+ */
+export declare function getAwsAccountId(): Promise<string | null>;
+/**
+ * Check if gcloud CLI is installed and authenticated enough to list clusters.
  */
 export declare function checkGcloudCli(): Promise<CloudCliStatus>;
 /**
  * Get the active GCP project ID
  */
 export declare function getGcpProjectId(): Promise<string | null>;
-/**
- * Check if GCP Application Default Credentials (ADC) are configured
- * ADC is required for Terraform to authenticate with Google Cloud
- */
-export declare function checkGcpApplicationDefaultCredentials(): Promise<{
-    configured: boolean;
-    error?: string;
-}>;
 /**
  * List available GCP regions
  */
@@ -71,25 +125,63 @@ export declare function listGcpRegions(): Promise<string[]>;
  * List GCS buckets
  */
 export declare function listGcsBuckets(): Promise<string[]>;
+/**
+ * List GCP service accounts for selection (e.g. for GKE Workload Identity).
+ * Returns an empty list on any failure so callers can fall back to manual entry.
+ */
+export declare function listGcpServiceAccounts(): Promise<GcpServiceAccount[]>;
 /**
  * List GKE clusters in a specific region
  * Note: GKE supports both regional and zonal clusters. We search for regional clusters.
  */
 export declare function listGkeClusters(region: string): Promise<string[]>;
 /**
- * Check if Azure CLI is installed and fully authenticated
- *
- * For Azure to be considered "authenticated", the user must have:
- * 1. Logged in with `az login`
- * 2. An active subscription in "Enabled" state
- * 3. Required resource providers registered (Microsoft.ContainerService, etc.)
- * 4. Sufficient vCPU quota for at least the small tier (8 cores)
+ * List GKE clusters across the active GCP project.
+ */
+export declare function listAllGkeClusters(): Promise<DiscoveredCluster[]>;
+/**
+ * Discover running GKE clusters in a selected region/location.
+ */
+export declare function discoverGkeClustersInRegion(region: string): Promise<DiscoveredCluster[]>;
+/**
+ * Check if Azure CLI is installed and authenticated enough to list clusters.
  */
 export declare function checkAzureCli(): Promise<CloudCliStatus>;
 /**
  * Get the active Azure subscription ID
  */
 export declare function getAzureSubscriptionId(): Promise<string | null>;
+/**
+ * Get the active Azure tenant ID. Used to auto-fill workload-identity tenant
+ * fields so users don't have to look it up manually.
+ */
+export declare function getAzureTenantId(): Promise<string | null>;
+/**
+ * List Azure user-assigned managed identities for selection (workload identity
+ * client IDs). Returns an empty list on any failure so callers can fall back to
+ * manual entry.
+ */
+export declare function listAzureManagedIdentities(): Promise<AzureManagedIdentity[]>;
+/**
+ * A Prometheus remote_write target the user can write to, with the full URL
+ * pre-assembled so the wizard never has to hand-build it.
+ */
+export interface RemoteWriteTarget {
+    name: string;
+    url: string;
+}
+/**
+ * Discovers Azure Monitor Prometheus remote_write targets: every Data Collection
+ * Rule that ingests the Microsoft-PrometheusMetrics stream, paired with its Data
+ * Collection Endpoint's metrics-ingestion endpoint, assembled into the exact
+ * remote_write URL. Works for any DCR the caller can see (not just ones we made).
+ */
+export declare function listAzurePrometheusTargets(): Promise<RemoteWriteTarget[]>;
+/**
+ * Discovers AWS Managed Prometheus (AMP) workspaces in a region and assembles the
+ * remote_write URL (<prometheusEndpoint>api/v1/remote_write) for each.
+ */
+export declare function listAwsPrometheusWorkspaces(region: string): Promise<RemoteWriteTarget[]>;
 /**
  * List available Azure regions (locations)
  */
@@ -107,30 +199,13 @@ export declare function listAzureBlobContainers(storageAccount: string): Promise
  */
 export declare function listAksClusters(resourceGroup?: string): Promise<string[]>;
 /**
- * Azure tier to vCPU core requirements mapping
+ * List AKS clusters across the active Azure subscription.
  */
-export declare const AZURE_TIER_CORES: Record<string, number>;
+export declare function listAllAksClusters(): Promise<DiscoveredCluster[]>;
 /**
- * Check if required Azure resource providers are registered
+ * Discover running AKS clusters in a selected Azure location.
  */
-export declare function checkAzureResourceProviders(): Promise<{
-    allRegistered: boolean;
-    missing: string[];
-}>;
-/**
- * Check Azure VM quota for a specific region
- *
- * @param region - Azure region to check quota for
- * @param requiredCores - Number of vCPUs required
- * @returns Quota check result with availability info
- */
-export declare function checkAzureVmQuota(region: string, requiredCores: number): Promise<{
-    sufficient: boolean;
-    available: number;
-    limit: number;
-    used: number;
-    error?: string;
-}>;
+export declare function discoverAksClustersInRegion(region: string): Promise<DiscoveredCluster[]>;
 /**
  * Check all cloud CLIs in parallel
  */
@@ -149,6 +224,22 @@ export declare function listBuckets(provider: CloudProvider): Promise<string[]>;
 export declare function listClusters(provider: CloudProvider, region: string, options?: {
     azureResourceGroup?: string;
 }): Promise<string[]>;
+/**
+ * List managed Kubernetes clusters discoverable through a provider CLI.
+ */
+export declare function listManagedClusters(provider: CloudProvider): Promise<DiscoveredCluster[]>;
+/**
+ * List managed Kubernetes clusters discoverable through a provider CLI in a
+ * selected region/location. This is used by init to avoid account-wide fan-out.
+ */
+export declare function discoverClustersInRegion(provider: CloudProvider, region: string): Promise<DiscoveredCluster[]>;
+/**
+ * Refresh kubeconfig credentials for a selected managed Kubernetes cluster.
+ */
+export declare function updateKubeconfig(provider: CloudProvider, clusterName: string, region: string, options?: {
+    gcpProjectId?: string;
+    azureResourceGroup?: string;
+}): Promise<void>;
 /**
  * Get installation URLs for cloud CLIs
  */
@@ -161,26 +252,6 @@ export declare const CLI_INSTALL_URLS: Record<CloudProvider, {
  * Get login commands for cloud CLIs
  */
 export declare const CLI_LOGIN_COMMANDS: Record<CloudProvider, string | string[]>;
-/**
- * Terraform installation status
- */
-export interface TerraformStatus {
-    installed: boolean;
-    version?: string;
-    error?: string;
-}
-/**
- * Check if Terraform is installed
- */
-export declare function checkTerraform(): Promise<TerraformStatus>;
-/**
- * Terraform installation info
- */
-export declare const TERRAFORM_INSTALL_INFO: {
-    name: string;
-    url: string;
-    installCmd: string;
-};
 /**
  * List S3 buckets in a specific region
  * Note: S3 buckets are global, but we filter by region