@flui-cloud/cli 0.0.1

package/lib/cli/src/commands/env/storage-expand.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class EnvStorageExpand extends Command {
+    static readonly description: string;
+    static readonly examples: string[];
+    static readonly flags: {
+        size: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+        confirm: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/lib/cli/src/commands/env/storage-expand.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const nest_app_1 = require("../../lib/nest-app");
+const context_banner_1 = require("../../lib/context-banner");
+const cli_observability_cluster_service_1 = require("../../services/cli-observability-cluster.service");
+const cluster_node_scaling_service_1 = require("../../../../src/modules/infrastructure/clusters/services/cluster-node-scaling.service");
+const cluster_storage_service_1 = require("../../../../src/modules/infrastructure/clusters/services/cluster-storage.service");
+const cluster_capacity_service_1 = require("../../../../src/modules/infrastructure/clusters/services/cluster-capacity.service");
+const prompts_1 = require("../../lib/prompts");
+class EnvStorageExpand extends core_1.Command {
+    async run() {
+        const { flags } = await this.parse(EnvStorageExpand);
+        (0, context_banner_1.printContextBanner)();
+        const spinner = (0, ora_1.default)('Inspecting current storage...').start();
+        try {
+            const app = await (0, nest_app_1.getNestApp)();
+            const observabilityService = app.get(cli_observability_cluster_service_1.CliObservabilityClusterService);
+            const storageService = app.get(cluster_storage_service_1.ClusterStorageService);
+            const capacityService = app.get(cluster_capacity_service_1.ClusterCapacityService);
+            const scalingService = app.get(cluster_node_scaling_service_1.ClusterNodeScalingService);
+            const cluster = await observabilityService.getObservabilityCluster();
+            if (!cluster) {
+                spinner.fail('No observability cluster found');
+                return;
+            }
+            const storage = await storageService.getStatus(cluster.id);
+            let plan;
+            try {
+                plan = await capacityService.getPlan(cluster.id);
+            }
+            catch (err) {
+                this.warn(`Capacity plan unavailable (${err.message}). ` +
+                    'Proceeding without per-GB cost estimate.');
+            }
+            spinner.succeed('Storage status retrieved');
+            if (!storage.volume) {
+                console.log(chalk_1.default.red('\n❌ Cluster has no Flui-managed shared-storage volume to expand.\n'));
+                this.exit(1);
+            }
+            const currentSize = storage.volume.sizeGb;
+            const targetSize = flags.size ?? currentSize + 10;
+            if (targetSize <= currentSize) {
+                console.log(chalk_1.default.red(`\n❌ Target size (${targetSize} GB) must be greater than current (${currentSize} GB). Volumes cannot shrink.\n`));
+                this.exit(1);
+            }
+            if (flags.size === undefined) {
+                const label = `${targetSize} GB`;
+                console.log(chalk_1.default.dim(`   (auto-selected target size: ${chalk_1.default.bold(label)} = current + 10 GB)`));
+            }
+            const deltaGb = targetSize - currentSize;
+            const pricePerGb = plan?.storage?.pricePerGbMonthlyEur;
+            const monthlyDelta = pricePerGb
+                ? (Number.parseFloat(pricePerGb) * deltaGb).toFixed(2)
+                : null;
+            console.log(chalk_1.default.cyan('\n💾 Expand Shared Volume Plan\n'));
+            console.log(`   ${chalk_1.default.bold('Cluster:')}    ${cluster.name}`);
+            console.log(`   ${chalk_1.default.bold('Volume:')}     ${storage.volume.volumeId}`);
+            console.log(`   ${chalk_1.default.bold('From:')}       ${currentSize} GB → ${targetSize} GB (+${deltaGb} GB)`);
+            if (monthlyDelta) {
+                console.log(`   ${chalk_1.default.bold('Cost:')}       +€${monthlyDelta}/month (€${pricePerGb}/GB)`);
+            }
+            console.log(`   ${chalk_1.default.bold('Downtime:')}   none (online ext4 resize)`);
+            if (!flags.confirm) {
+                console.log('');
+                console.log(chalk_1.default.yellow(`   To confirm, type the cluster name exactly: ${chalk_1.default.bold(cluster.name)}`));
+                const ok = await (0, prompts_1.confirmByTypingPrompt)(chalk_1.default.yellow('⚠️  Cluster name'), cluster.name);
+                if (!ok) {
+                    console.log(chalk_1.default.green('\n✅ Cancelled\n'));
+                    return;
+                }
+            }
+            const run = (0, ora_1.default)({
+                text: `Expanding volume to ${targetSize} GB...`,
+                color: 'yellow',
+            }).start();
+            try {
+                const op = await scalingService.expandSharedVolume(cluster.id, {
+                    targetSizeGb: targetSize,
+                });
+                run.succeed(`Volume expanded. Operation ${op.id} → ${op.status}`);
+                if (op.metadata?.fsResizeWarning) {
+                    console.log(chalk_1.default.yellow(`   ⚠️  Filesystem resize warning: ${op.metadata.fsResizeWarning}`));
+                }
+            }
+            catch (error) {
+                run.fail('Volume expand failed');
+                throw error;
+            }
+            console.log('');
+        }
+        catch (error) {
+            console.log(chalk_1.default.red('\n❌ Error:\n'));
+            console.log(`   ${error instanceof Error ? error.message : String(error)}\n`);
+            this.exit(1);
+        }
+        finally {
+            await (0, nest_app_1.closeNestApp)();
+        }
+    }
+}
+EnvStorageExpand.description = 'Grow the cluster shared-storage backing Volume. Resizes the provider Volume, ' +
+    'then runs resize2fs over SSH on the master so the new space is usable. ' +
+    'Online for ext4 — no downtime expected. Volumes can only grow.';
+EnvStorageExpand.examples = [
+    '<%= config.bin %> <%= command.id %> --size 50',
+    '<%= config.bin %> <%= command.id %> --size 100 --confirm',
+];
+EnvStorageExpand.flags = {
+    size: core_1.Flags.integer({
+        char: 's',
+        description: 'New volume size in GB (must be greater than current). If omitted, defaults to current + 10 GB.',
+    }),
+    confirm: core_1.Flags.boolean({
+        description: 'Skip the typed confirmation prompt',
+        default: false,
+    }),
+};
+exports.default = EnvStorageExpand;

package/lib/cli/src/commands/env/storage.d.ts

@@ -0,0 +1,8 @@
+import { Command } from '@oclif/core';
+export default class EnvStorage extends Command {
+    static readonly description = "Show shared storage status (Volume + NFS export + PVC summary) for the current observability cluster";
+    static readonly examples: string[];
+    run(): Promise<void>;
+    private render;
+    private formatStatus;
+}

package/lib/cli/src/commands/env/storage.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const nest_app_1 = require("../../lib/nest-app");
+const cli_observability_cluster_service_1 = require("../../services/cli-observability-cluster.service");
+const cluster_storage_service_1 = require("../../../../src/modules/infrastructure/clusters/services/cluster-storage.service");
+const cluster_storage_dto_1 = require("../../../../src/modules/infrastructure/clusters/dto/cluster-storage.dto");
+const context_banner_1 = require("../../lib/context-banner");
+class EnvStorage extends core_1.Command {
+    async run() {
+        (0, context_banner_1.printContextBanner)();
+        const spinner = (0, ora_1.default)('Inspecting shared storage...').start();
+        try {
+            const app = await (0, nest_app_1.getNestApp)();
+            const observabilityService = app.get(cli_observability_cluster_service_1.CliObservabilityClusterService);
+            const storageService = app.get(cluster_storage_service_1.ClusterStorageService);
+            const cluster = await observabilityService.getObservabilityCluster();
+            if (!cluster) {
+                spinner.fail('No observability cluster found');
+                console.log(chalk_1.default.yellow('\n⚠️  Create a cluster first: ' + chalk_1.default.cyan('flui env create\n')));
+                return;
+            }
+            const status = await storageService.getStatus(cluster.id);
+            spinner.succeed('Storage status retrieved');
+            this.render(status);
+        }
+        catch (error) {
+            spinner.fail('Failed to retrieve storage status');
+            console.log(chalk_1.default.red('\n❌ Error:\n'));
+            console.log(`   ${error instanceof Error ? error.message : String(error)}\n`);
+            this.exit(1);
+        }
+        finally {
+            await (0, nest_app_1.closeNestApp)();
+        }
+    }
+    render(s) {
+        console.log(chalk_1.default.cyan('\n💾 Cluster Shared Storage\n'));
+        console.log(`   ${chalk_1.default.bold('Status:')}  ${this.formatStatus(s.status)}`);
+        console.log(`   ${chalk_1.default.bold('Enabled:')} ${s.enabled ? 'yes' : 'no'}`);
+        if (s.message) {
+            console.log(`   ${chalk_1.default.dim(s.message)}`);
+        }
+        if (s.volume) {
+            console.log(chalk_1.default.cyan('\n📦 Backing Volume\n'));
+            console.log(`   ${chalk_1.default.bold('Provider:')}    ${s.volume.provider}`);
+            console.log(`   ${chalk_1.default.bold('Volume ID:')}   ${s.volume.volumeId}`);
+            console.log(`   ${chalk_1.default.bold('Size:')}        ${s.volume.sizeGb} GB`);
+            console.log(`   ${chalk_1.default.bold('Mount path:')}  ${s.volume.mountPath}`);
+            console.log(`   ${chalk_1.default.bold('FS label:')}    ${s.volume.fsLabel}`);
+        }
+        if (s.nfs) {
+            console.log(chalk_1.default.cyan('\n🌐 NFS Export\n'));
+            console.log(`   ${chalk_1.default.bold('Export path:')} ${s.nfs.exportPath}`);
+            console.log(`   ${chalk_1.default.bold('Server opts:')} ${chalk_1.default.dim(s.nfs.exportOptions)}`);
+            console.log(`   ${chalk_1.default.bold('Client opts:')} ${chalk_1.default.dim(s.nfs.mountOptions)}`);
+        }
+        if (s.pvcs) {
+            console.log(chalk_1.default.cyan('\n📂 PersistentVolumeClaims\n'));
+            console.log(`   ${chalk_1.default.bold('Bound PVCs:')}    ${s.pvcs.bound}`);
+            console.log(`   ${chalk_1.default.bold('Requested:')}     ${s.pvcs.requestedGb} GB`);
+            const namespaces = Object.entries(s.pvcs.byNamespace);
+            if (namespaces.length > 0) {
+                console.log(`   ${chalk_1.default.bold('By namespace:')}`);
+                const sortedNamespaces = [...namespaces].sort(([a], [b]) => a.localeCompare(b));
+                for (const [ns, count] of sortedNamespaces) {
+                    console.log(`     ${chalk_1.default.dim('•')} ${ns}: ${count}`);
+                }
+            }
+        }
+        console.log('');
+    }
+    formatStatus(status) {
+        const map = {
+            [cluster_storage_dto_1.ClusterStorageStatus.READY]: chalk_1.default.green,
+            [cluster_storage_dto_1.ClusterStorageStatus.PROVISIONING]: chalk_1.default.yellow,
+            [cluster_storage_dto_1.ClusterStorageStatus.DEGRADED]: chalk_1.default.yellow,
+            [cluster_storage_dto_1.ClusterStorageStatus.ERROR]: chalk_1.default.red,
+            [cluster_storage_dto_1.ClusterStorageStatus.DISABLED]: chalk_1.default.dim,
+            [cluster_storage_dto_1.ClusterStorageStatus.UNKNOWN]: chalk_1.default.white,
+        };
+        return (map[status] ?? chalk_1.default.white)(status);
+    }
+}
+EnvStorage.description = 'Show shared storage status (Volume + NFS export + PVC summary) for the current observability cluster';
+EnvStorage.examples = ['<%= config.bin %> <%= command.id %>'];
+exports.default = EnvStorage;

package/lib/cli/src/commands/env/sync.d.ts

@@ -0,0 +1,17 @@
+import { Command } from '@oclif/core';
+export default class EnvSync extends Command {
+    static readonly description: string;
+    static readonly examples: string[];
+    static readonly flags: {
+        'dry-run': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        debug: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private buildEnvVars;
+    private resolveOidcIssuer;
+    private resolveOidcJwksUri;
+    private deriveApiUrl;
+    private displayEndpoints;
+    private displayDiff;
+    private writeEnvFile;
+}

package/lib/cli/src/commands/env/sync.js

@@ -0,0 +1,225 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const nest_app_1 = require("../../lib/nest-app");
+const cli_observability_cluster_service_1 = require("../../services/cli-observability-cluster.service");
+const cli_endpoint_resolver_service_1 = require("../../services/cli-endpoint-resolver.service");
+const cli_ssh_service_1 = require("../../services/cli-ssh.service");
+const config_storage_1 = require("../../lib/config-storage");
+const cluster_entity_1 = require("../../../../src/modules/infrastructure/clusters/entities/cluster.entity");
+const env_file_1 = require("../../lib/utils/env-file");
+const context_banner_1 = require("../../lib/context-banner");
+class EnvSync extends core_1.Command {
+    async run() {
+        const { flags } = await this.parse(EnvSync);
+        (0, context_banner_1.printContextBanner)();
+        const spinner = (0, ora_1.default)('Connecting to cluster master via SSH...').start();
+        try {
+            const app = await (0, nest_app_1.getNestApp)();
+            const observabilityService = app.get(cli_observability_cluster_service_1.CliObservabilityClusterService);
+            const resolver = app.get(cli_endpoint_resolver_service_1.CliEndpointResolverService);
+            const sshService = app.get(cli_ssh_service_1.CliSshService);
+            const cluster = await observabilityService.getObservabilityCluster();
+            if (!cluster) {
+                spinner.fail('No observability cluster found');
+                console.log(chalk_1.default.yellow('\n⚠️  No observability cluster exists.\n'));
+                console.log(chalk_1.default.dim('Create one with:'));
+                console.log(`   ${chalk_1.default.cyan('flui env create')}\n`);
+                return;
+            }
+            if (cluster.status !== cluster_entity_1.ClusterStatus.READY) {
+                spinner.fail(`Cluster is not ready (status: ${cluster.status})`);
+                return;
+            }
+            const masterIp = cluster.masterIpAddress;
+            if (!masterIp) {
+                spinner.fail('Master IP address not available');
+                return;
+            }
+            const endpoints = await resolver.resolveEndpoints(masterIp, cluster.nipHostnameToken);
+            spinner.succeed('Endpoints resolved from cluster');
+            if (flags.debug) {
+                console.log(chalk_1.default.cyan('\n🔬 Debug: ingresses on cluster\n'));
+                try {
+                    const raw = await sshService.sshExec(masterIp, "kubectl get ingress -A -o custom-columns='NAMESPACE:.metadata.namespace,NAME:.metadata.name,HOSTS:.spec.rules[*].host,LABELS:.metadata.labels' 2>/dev/null || echo '(kubectl failed)'");
+                    console.log(raw || chalk_1.default.dim('(no ingresses found)'));
+                }
+                catch (err) {
+                    console.log(chalk_1.default.red(`Debug failed: ${err instanceof Error ? err.message : String(err)}`));
+                }
+                console.log();
+            }
+            const envVars = this.buildEnvVars(endpoints);
+            this.displayEndpoints(cluster.name, masterIp, endpoints);
+            const configStorage = new config_storage_1.ConfigStorage();
+            const previousApiUrl = configStorage.getApiUrl();
+            const nextApiUrl = this.deriveApiUrl(endpoints);
+            this.displayDiff(previousApiUrl, nextApiUrl, envVars);
+            if (flags['dry-run']) {
+                console.log(chalk_1.default.yellow('\n🔍 Dry run mode — no changes applied.\n'));
+                return;
+            }
+            this.writeEnvFile(envVars);
+            configStorage.saveApiUrl(nextApiUrl);
+            console.log(chalk_1.default.green('\n✅ Endpoints synced successfully.\n'));
+        }
+        catch (error) {
+            spinner.fail('Failed to sync endpoints');
+            console.error(chalk_1.default.red(`\n❌ ${error instanceof Error ? error.message : String(error)}\n`));
+            console.log(chalk_1.default.dim('Troubleshooting: verify SSH access to the master node and that `kubectl` is available there.\n'));
+            this.exit(1);
+        }
+        finally {
+            await (0, nest_app_1.closeNestApp)();
+        }
+    }
+    buildEnvVars(endpoints) {
+        const envVars = {
+            AUTH_MODE: endpoints.authMode,
+            GRAFANA_URL: endpoints.grafana.effectiveUrl,
+            PROMETHEUS_ENDPOINT: endpoints.prometheus.effectiveUrl,
+            LOKI_ENDPOINT: endpoints.loki.effectiveUrl,
+        };
+        const issuer = this.resolveOidcIssuer(endpoints);
+        if (issuer)
+            envVars.OIDC_ISSUER = issuer;
+        const jwks = this.resolveOidcJwksUri(endpoints, issuer);
+        if (jwks)
+            envVars.OIDC_JWKS_URI = jwks;
+        if (endpoints.oidcAudience) {
+            envVars.OIDC_AUDIENCE = endpoints.oidcAudience;
+        }
+        return envVars;
+    }
+    resolveOidcIssuer(endpoints) {
+        // Prefer the Ingress (source of truth for the live domain) over the ConfigMap,
+        // which can lag behind when the auth-domain-sync hasn't caught up.
+        if (endpoints.zitadel.fqdn)
+            return `https://${endpoints.zitadel.fqdn}`;
+        if (endpoints.oidcIssuer)
+            return endpoints.oidcIssuer;
+        return '';
+    }
+    resolveOidcJwksUri(endpoints, issuer) {
+        const raw = endpoints.oidcJwksUri;
+        const isInCluster = raw.includes('.svc.cluster.local');
+        if (raw && !isInCluster)
+            return raw;
+        if (issuer)
+            return `${issuer.replace(/\/$/, '')}/oauth/v2/keys`;
+        return '';
+    }
+    deriveApiUrl(endpoints) {
+        const base = endpoints.fluiApi.effectiveUrl.replace(/\/$/, '');
+        return base.endsWith('/api/v1') ? base : `${base}/api/v1`;
+    }
+    displayEndpoints(clusterName, masterIp, endpoints) {
+        console.log(chalk_1.default.cyan('\n📋 Resolved Endpoints\n'));
+        console.log(`   ${chalk_1.default.bold('Cluster:')}    ${clusterName}`);
+        console.log(`   ${chalk_1.default.bold('Master IP:')}  ${masterIp}`);
+        console.log(`   ${chalk_1.default.bold('Auth mode:')}  ${endpoints.authMode}\n`);
+        const rows = [
+            ['Flui API', endpoints.fluiApi],
+            ['Flui Web', endpoints.fluiWeb],
+            ['Zitadel', endpoints.zitadel],
+            ['Grafana', endpoints.grafana],
+            ['Prometheus', endpoints.prometheus],
+            ['Loki', endpoints.loki],
+        ];
+        for (const [label, info] of rows) {
+            const marker = info.synced ? chalk_1.default.green('●') : chalk_1.default.dim('○');
+            const url = info.synced
+                ? chalk_1.default.blue(info.effectiveUrl)
+                : chalk_1.default.dim(info.effectiveUrl);
+            console.log(`   ${marker} ${chalk_1.default.bold(label.padEnd(12))} ${url}`);
+        }
+    }
+    displayDiff(previousApiUrl, nextApiUrl, envVars) {
+        console.log(chalk_1.default.cyan('\n🔄 Changes to apply:\n'));
+        if (previousApiUrl === nextApiUrl) {
+            console.log(`   ${chalk_1.default.dim('apiUrl unchanged:')} ${previousApiUrl}`);
+        }
+        else {
+            console.log(`   ${chalk_1.default.bold('apiUrl (config.json):')}`);
+            console.log(`     ${chalk_1.default.red('- ' + previousApiUrl)}`);
+            console.log(`     ${chalk_1.default.green('+ ' + nextApiUrl)}`);
+        }
+        console.log(`\n   ${chalk_1.default.bold('.env keys:')}`);
+        for (const [k, v] of Object.entries(envVars)) {
+            const shown = /SECRET|KEY|PASSWORD|AUDIENCE/i.test(k)
+                ? chalk_1.default.yellow('******')
+                : v;
+            console.log(`     ${k}=${shown}`);
+        }
+    }
+    writeEnvFile(envVars) {
+        const envPath = path.join(process.cwd(), '.env');
+        const envExamplePath = path.join(process.cwd(), '.env.example');
+        let existing = '';
+        if (fs.existsSync(envPath)) {
+            existing = fs.readFileSync(envPath, 'utf-8');
+        }
+        else if (fs.existsSync(envExamplePath)) {
+            existing = fs.readFileSync(envExamplePath, 'utf-8');
+        }
+        const updated = (0, env_file_1.updateEnvContent)(existing, envVars);
+        fs.writeFileSync(envPath, updated, 'utf-8');
+    }
+}
+EnvSync.description = 'Sync endpoint URLs (API, OIDC, observability) from the cluster via SSH+kubectl.\n' +
+    'Safe for production: reads only K8s Ingress/ConfigMap/Secret, never touches DB/Redis credentials.';
+EnvSync.examples = [
+    '<%= config.bin %> <%= command.id %>',
+    '<%= config.bin %> <%= command.id %> --dry-run',
+];
+EnvSync.flags = {
+    'dry-run': core_1.Flags.boolean({
+        description: 'Show what would change without modifying .env or config.json',
+        default: false,
+    }),
+    debug: core_1.Flags.boolean({
+        description: 'Print raw ingress list from the cluster for diagnostics',
+        default: false,
+    }),
+};
+exports.default = EnvSync;

package/lib/cli/src/commands/env/uncordon.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class EnvUncordon extends Command {
+    static readonly description: string;
+    static readonly examples: string[];
+    static readonly args: {
+        target: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/cli/src/commands/env/uncordon.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const nest_app_1 = require("../../lib/nest-app");
+const context_banner_1 = require("../../lib/context-banner");
+const cli_observability_cluster_service_1 = require("../../services/cli-observability-cluster.service");
+const cli_node_repository_1 = require("../../lib/repositories/cli-node.repository");
+const cluster_node_entity_1 = require("../../../../src/modules/infrastructure/clusters/entities/cluster-node.entity");
+const cli_ssh_service_1 = require("../../services/cli-ssh.service");
+class EnvUncordon extends core_1.Command {
+    async run() {
+        const { args } = await this.parse(EnvUncordon);
+        (0, context_banner_1.printContextBanner)();
+        const spinner = (0, ora_1.default)('Resolving node...').start();
+        try {
+            const app = await (0, nest_app_1.getNestApp)();
+            const observabilityService = app.get(cli_observability_cluster_service_1.CliObservabilityClusterService);
+            const nodeRepo = app.get(cli_node_repository_1.CliNodeRepository);
+            const ssh = app.get(cli_ssh_service_1.CliSshService);
+            const cluster = await observabilityService.getObservabilityCluster();
+            if (!cluster) {
+                spinner.fail('No observability cluster found');
+                return;
+            }
+            const nodes = await nodeRepo.find({ where: { clusterId: cluster.id } });
+            const target = args.target === 'master'
+                ? nodes.find((n) => n.nodeType === cluster_node_entity_1.NodeType.MASTER)
+                : nodes.find((n) => n.serverName === args.target);
+            if (!target) {
+                spinner.fail(`Node "${args.target}" not found`);
+                this.exit(1);
+            }
+            if (!cluster.masterIpAddress) {
+                spinner.fail('Cluster has no masterIpAddress stored');
+                this.exit(1);
+            }
+            spinner.text = `Uncordoning ${target.serverName} via SSH to master...`;
+            const out = await ssh.sshExec(cluster.masterIpAddress, `kubectl uncordon ${target.serverName}`);
+            spinner.succeed(`Node ${target.serverName} is now schedulable`);
+            if (out.trim()) {
+                console.log(chalk_1.default.dim(`   ${out.trim()}`));
+            }
+            console.log('');
+        }
+        catch (error) {
+            spinner.fail('Uncordon failed');
+            console.log(chalk_1.default.red('\n❌ Error:\n'));
+            console.log(`   ${error instanceof Error ? error.message : String(error)}\n`);
+            this.exit(1);
+        }
+        finally {
+            await (0, nest_app_1.closeNestApp)();
+        }
+    }
+}
+EnvUncordon.description = 'Mark a cluster node schedulable again. Recovery helper for when a scale-node ' +
+    'operation interrupted before reaching the uncordon step.';
+EnvUncordon.examples = [
+    '<%= config.bin %> <%= command.id %> master',
+    '<%= config.bin %> <%= command.id %> worker-1',
+];
+EnvUncordon.args = {
+    target: core_1.Args.string({
+        description: 'Node target: "master" or a worker node serverName',
+        required: true,
+    }),
+};
+exports.default = EnvUncordon;

package/lib/cli/src/commands/env/update-firewall.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class EnvUpdateFirewall extends Command {
+    static readonly description = "Create or update firewall IP ranges for observability cluster";
+    static readonly examples: string[];
+    static readonly flags: {
+        ip: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}