@flui-cloud/cli 0.0.1

package/lib/src/modules/frameworks/framework-core/enums/build-stage.enum.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildMode = exports.BuildStage = void 0;
+/**
+ * Docker build stages
+ */
+var BuildStage;
+(function (BuildStage) {
+    BuildStage["DEPENDENCIES"] = "dependencies";
+    BuildStage["BUILD"] = "build";
+    BuildStage["RUNTIME"] = "runtime";
+    BuildStage["CUSTOM"] = "custom";
+})(BuildStage || (exports.BuildStage = BuildStage = {}));
+/**
+ * Build mode for frameworks that support multiple output modes
+ */
+var BuildMode;
+(function (BuildMode) {
+    // Next.js modes
+    BuildMode["SSR"] = "ssr";
+    BuildMode["STATIC"] = "static";
+    BuildMode["STANDALONE"] = "standalone";
+    // Angular modes
+    BuildMode["SPA"] = "spa";
+    BuildMode["SSR_ANGULAR"] = "ssr-angular";
+    // Generic modes
+    BuildMode["PRODUCTION"] = "production";
+    BuildMode["DEVELOPMENT"] = "development";
+})(BuildMode || (exports.BuildMode = BuildMode = {}));

package/lib/src/modules/frameworks/framework-core/enums/deploy-strategy.enum.d.ts

@@ -0,0 +1,22 @@
+export declare enum DeployStrategy {
+    /**
+     * Let Railpack handle everything automatically.
+     * Used for high-confidence frameworks with clear, predictable structure.
+     */
+    RAILPACK_DIRECT = "railpack_direct",
+    /**
+     * Use Railpack but inject explicit build/start command overrides via railway.toml.
+     * Used when the framework is recognized but commands are ambiguous or need guidance.
+     */
+    RAILPACK_WITH_OVERRIDES = "railpack_with_overrides",
+    /**
+     * Skip Railpack entirely and use a generated or provided Dockerfile.
+     * Used for stacks where Railpack support is inconsistent (.NET, Elixir, etc.).
+     */
+    DOCKERFILE = "dockerfile",
+    /**
+     * Project structure is not ready for deployment.
+     * Build is blocked with human-readable recommendations.
+     */
+    NEEDS_ADJUSTMENT = "needs_adjustment"
+}

package/lib/src/modules/frameworks/framework-core/enums/deploy-strategy.enum.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeployStrategy = void 0;
+var DeployStrategy;
+(function (DeployStrategy) {
+    /**
+     * Let Railpack handle everything automatically.
+     * Used for high-confidence frameworks with clear, predictable structure.
+     */
+    DeployStrategy["RAILPACK_DIRECT"] = "railpack_direct";
+    /**
+     * Use Railpack but inject explicit build/start command overrides via railway.toml.
+     * Used when the framework is recognized but commands are ambiguous or need guidance.
+     */
+    DeployStrategy["RAILPACK_WITH_OVERRIDES"] = "railpack_with_overrides";
+    /**
+     * Skip Railpack entirely and use a generated or provided Dockerfile.
+     * Used for stacks where Railpack support is inconsistent (.NET, Elixir, etc.).
+     */
+    DeployStrategy["DOCKERFILE"] = "dockerfile";
+    /**
+     * Project structure is not ready for deployment.
+     * Build is blocked with human-readable recommendations.
+     */
+    DeployStrategy["NEEDS_ADJUSTMENT"] = "needs_adjustment";
+})(DeployStrategy || (exports.DeployStrategy = DeployStrategy = {}));

package/lib/src/modules/frameworks/framework-core/enums/framework-type.enum.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Supported framework types for deployment
+ */
+export declare enum FrameworkType {
+    DOCKERFILE = "dockerfile",
+    NEXTJS = "nextjs",
+    ANGULAR = "angular",
+    NESTJS = "nestjs",
+    REACT_ROUTER = "react-router",
+    REMIX = "remix",
+    NUXT = "nuxt",
+    SVELTE_KIT = "svelte-kit",
+    REACT_VITE = "react-vite",
+    ASTRO = "astro",
+    VUE_VITE = "vue-vite",
+    TANSTACK_START = "tanstack-start",
+    EXPRESS = "express",
+    FASTHTML = "fasthtml",
+    FASTAPI = "fastapi",
+    DJANGO = "django",
+    FLASK = "flask",
+    SPRING_BOOT = "spring-boot",
+    RAILS = "rails",
+    LARAVEL = "laravel",
+    ASPNET_CORE = "aspnet-core",
+    PHOENIX = "phoenix",
+    GO = "go",
+    STATIC_HTML = "static-html",
+    GENERIC_NODE = "generic-node",
+    GENERIC_PYTHON = "generic-python",
+    UNKNOWN = "unknown"
+}

package/lib/src/modules/frameworks/framework-core/enums/framework-type.enum.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FrameworkType = void 0;
+/**
+ * Supported framework types for deployment
+ */
+var FrameworkType;
+(function (FrameworkType) {
+    // Passthrough - use existing Dockerfile
+    FrameworkType["DOCKERFILE"] = "dockerfile";
+    // JavaScript/TypeScript Frameworks
+    FrameworkType["NEXTJS"] = "nextjs";
+    FrameworkType["ANGULAR"] = "angular";
+    FrameworkType["NESTJS"] = "nestjs";
+    FrameworkType["REACT_ROUTER"] = "react-router";
+    FrameworkType["REMIX"] = "remix";
+    FrameworkType["NUXT"] = "nuxt";
+    FrameworkType["SVELTE_KIT"] = "svelte-kit";
+    FrameworkType["REACT_VITE"] = "react-vite";
+    FrameworkType["ASTRO"] = "astro";
+    FrameworkType["VUE_VITE"] = "vue-vite";
+    FrameworkType["TANSTACK_START"] = "tanstack-start";
+    FrameworkType["EXPRESS"] = "express";
+    // Python Frameworks
+    FrameworkType["FASTHTML"] = "fasthtml";
+    FrameworkType["FASTAPI"] = "fastapi";
+    FrameworkType["DJANGO"] = "django";
+    FrameworkType["FLASK"] = "flask";
+    // Java Frameworks
+    FrameworkType["SPRING_BOOT"] = "spring-boot";
+    // Ruby Frameworks
+    FrameworkType["RAILS"] = "rails";
+    // PHP Frameworks
+    FrameworkType["LARAVEL"] = "laravel";
+    // .NET Frameworks
+    FrameworkType["ASPNET_CORE"] = "aspnet-core";
+    // Elixir Frameworks
+    FrameworkType["PHOENIX"] = "phoenix";
+    // Go
+    FrameworkType["GO"] = "go";
+    // Static Sites
+    FrameworkType["STATIC_HTML"] = "static-html";
+    // Generic/Fallback
+    FrameworkType["GENERIC_NODE"] = "generic-node";
+    FrameworkType["GENERIC_PYTHON"] = "generic-python";
+    FrameworkType["UNKNOWN"] = "unknown";
+})(FrameworkType || (exports.FrameworkType = FrameworkType = {}));

package/lib/src/modules/grafana/services/grafana-config.service.d.ts

@@ -0,0 +1,43 @@
+import { ConfigService } from '@nestjs/config';
+import { Repository } from 'typeorm';
+import { ClusterEntity } from '../../infrastructure/clusters/entities/cluster.entity';
+/**
+ * Service for retrieving Grafana configuration and credentials
+ * This service breaks the circular dependency by directly querying the clusters table
+ * instead of depending on ObservabilityClusterService
+ */
+export declare class GrafanaConfigService {
+    private readonly clusterRepository;
+    private readonly configService;
+    private readonly logger;
+    constructor(clusterRepository: Repository<ClusterEntity>, configService: ConfigService);
+    /**
+     * Get Grafana URL and credentials from observability cluster metadata
+     * @returns Grafana endpoint URL, username, and admin password
+     */
+    getGrafanaCredentials(): Promise<{
+        url: string;
+        username: string;
+        password: string;
+    }>;
+    /**
+     * Get the observability cluster entity
+     * @returns ObservabilityCluster entity or null if not found
+     */
+    getObservabilityCluster(): Promise<ClusterEntity | null>;
+    /**
+     * Get Grafana endpoint URL
+     * @returns Grafana HTTP endpoint (e.g., "http://1.2.3.4:30300")
+     */
+    getGrafanaEndpoint(): Promise<string | null>;
+    /**
+     * Get Grafana admin password
+     * @returns Grafana admin password
+     */
+    getGrafanaPassword(): Promise<string | null>;
+    /**
+     * Get Basic Auth header for Grafana API
+     * @returns Base64 encoded Basic Auth credentials
+     */
+    getGrafanaAuthHeader(): Promise<string | null>;
+}

package/lib/src/modules/grafana/services/grafana-config.service.js

@@ -0,0 +1,177 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var GrafanaConfigService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrafanaConfigService = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const cluster_entity_1 = require("../../infrastructure/clusters/entities/cluster.entity");
+const nip_hostname_util_1 = require("../../dns/utils/nip-hostname.util");
+/**
+ * Service for retrieving Grafana configuration and credentials
+ * This service breaks the circular dependency by directly querying the clusters table
+ * instead of depending on ObservabilityClusterService
+ */
+let GrafanaConfigService = GrafanaConfigService_1 = class GrafanaConfigService {
+    constructor(clusterRepository, configService) {
+        this.clusterRepository = clusterRepository;
+        this.configService = configService;
+        this.logger = new common_1.Logger(GrafanaConfigService_1.name);
+    }
+    /**
+     * Get Grafana URL and credentials from observability cluster metadata
+     * @returns Grafana endpoint URL, username, and admin password
+     */
+    async getGrafanaCredentials() {
+        const obsCluster = await this.getObservabilityCluster();
+        if (!obsCluster) {
+            throw new Error('No observability cluster found - cannot manage Grafana datasources');
+        }
+        // Get Grafana endpoint and password from cluster metadata
+        const endpoints = obsCluster.metadata?.observabilityStack?.endpoints;
+        const passwords = obsCluster.metadata?.observabilityStack?.passwords;
+        // PRIORITY 1: Try metadata first (for API-created clusters)
+        if (endpoints?.grafana && passwords?.grafana) {
+            return {
+                url: endpoints.grafana,
+                username: 'admin', // API-created clusters always use 'admin'
+                password: passwords.grafana,
+            };
+        }
+        // PRIORITY 2: Try environment variables (complete configuration)
+        const envGrafanaUrl = this.configService.get('GRAFANA_URL');
+        const envGrafanaUsername = this.configService.get('GRAFANA_ADMIN_USERNAME');
+        const envGrafanaPassword = this.configService.get('GRAFANA_ADMIN_PASSWORD');
+        // If GRAFANA_URL is provided, use env vars for complete configuration
+        if (envGrafanaUrl) {
+            this.logger.log('Observability cluster metadata missing. Using GRAFANA_URL from environment variables.');
+            // Validate URL format
+            if (!envGrafanaUrl.startsWith('http://') &&
+                !envGrafanaUrl.startsWith('https://')) {
+                throw new Error('GRAFANA_URL must start with http:// or https://. ' +
+                    `Received: ${envGrafanaUrl}`);
+            }
+            if (!envGrafanaPassword) {
+                throw new Error('GRAFANA_ADMIN_PASSWORD environment variable not set. ' +
+                    'This is required when using GRAFANA_URL. ' +
+                    'Please set this variable and restart the application.');
+            }
+            const username = envGrafanaUsername || 'admin'; // Default to 'admin' if not specified
+            this.logger.log(`Using environment variables: ${envGrafanaUrl} (username: ${username})`);
+            return {
+                url: envGrafanaUrl,
+                username,
+                password: envGrafanaPassword,
+            };
+        }
+        // PRIORITY 3: FALLBACK - Construct URL from cluster IP + use env vars for credentials
+        this.logger.warn('Observability cluster metadata missing Grafana credentials. ' +
+            'Using fallback: cluster IP + environment variables for credentials');
+        if (!obsCluster.masterIpAddress) {
+            throw new Error('Observability cluster missing master IP address. ' +
+                'Cannot construct Grafana endpoint URL. ' +
+                'Please set GRAFANA_URL environment variable or ensure cluster has masterIpAddress.');
+        }
+        if (!envGrafanaPassword) {
+            throw new Error('GRAFANA_ADMIN_PASSWORD environment variable not set. ' +
+                'This is required for CLI-created observability clusters. ' +
+                'Please set this variable and restart the application.');
+        }
+        const grafanaUrl = `http://${(0, nip_hostname_util_1.buildSystemNipHostname)('grafana', obsCluster.masterIpAddress, obsCluster.nipHostnameToken)}`;
+        const username = envGrafanaUsername || 'admin'; // Default to 'admin' if not specified
+        this.logger.log(`Using fallback credentials: ${grafanaUrl} (username: ${username}, password from env)`);
+        return {
+            url: grafanaUrl,
+            username,
+            password: envGrafanaPassword,
+        };
+    }
+    /**
+     * Get the observability cluster entity
+     * @returns ObservabilityCluster entity or null if not found
+     */
+    async getObservabilityCluster() {
+        try {
+            const obsCluster = await this.clusterRepository.findOne({
+                where: {
+                    clusterType: cluster_entity_1.ClusterType.OBSERVABILITY,
+                    status: cluster_entity_1.ClusterStatus.READY,
+                },
+                order: { createdAt: 'DESC' },
+            });
+            if (!obsCluster) {
+                this.logger.warn('No READY observability cluster found in database');
+                return null;
+            }
+            this.logger.log(`Found observability cluster: ${obsCluster.name} (${obsCluster.id})`);
+            return obsCluster;
+        }
+        catch (error) {
+            this.logger.error(`Error retrieving observability cluster: ${error.message}`, error.stack);
+            return null;
+        }
+    }
+    /**
+     * Get Grafana endpoint URL
+     * @returns Grafana HTTP endpoint (e.g., "http://1.2.3.4:30300")
+     */
+    async getGrafanaEndpoint() {
+        try {
+            const credentials = await this.getGrafanaCredentials();
+            return credentials.url;
+        }
+        catch (error) {
+            this.logger.warn(`Failed to get Grafana endpoint: ${error.message}`);
+            return null;
+        }
+    }
+    /**
+     * Get Grafana admin password
+     * @returns Grafana admin password
+     */
+    async getGrafanaPassword() {
+        try {
+            const credentials = await this.getGrafanaCredentials();
+            return credentials.password;
+        }
+        catch (error) {
+            this.logger.warn(`Failed to get Grafana password: ${error.message}`);
+            return null;
+        }
+    }
+    /**
+     * Get Basic Auth header for Grafana API
+     * @returns Base64 encoded Basic Auth credentials
+     */
+    async getGrafanaAuthHeader() {
+        try {
+            const credentials = await this.getGrafanaCredentials();
+            const auth = Buffer.from(`admin:${credentials.password}`).toString('base64');
+            return `Basic ${auth}`;
+        }
+        catch (error) {
+            this.logger.warn(`Failed to get Grafana auth header: ${error.message}`);
+            return null;
+        }
+    }
+};
+exports.GrafanaConfigService = GrafanaConfigService;
+exports.GrafanaConfigService = GrafanaConfigService = GrafanaConfigService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(cluster_entity_1.ClusterEntity)),
+    __metadata("design:paramtypes", [typeorm_2.Repository,
+        config_1.ConfigService])
+], GrafanaConfigService);

package/lib/src/modules/grafana/services/grafana-datasource.service.d.ts

@@ -0,0 +1,70 @@
+import { ConfigService } from '@nestjs/config';
+import { Repository } from 'typeorm';
+import { ClusterEntity } from '../../infrastructure/clusters/entities/cluster.entity';
+import { GrafanaConfigService } from './grafana-config.service';
+/**
+ * Service for managing Grafana datasources via HTTP API
+ * Automatically adds/removes datasources when clusters are created/deleted
+ */
+export declare class GrafanaDatasourceService {
+    private readonly clusterRepository;
+    private readonly configService;
+    private readonly grafanaConfigService;
+    private readonly logger;
+    private grafanaClient;
+    constructor(clusterRepository: Repository<ClusterEntity>, configService: ConfigService, grafanaConfigService: GrafanaConfigService);
+    /**
+     * Add Prometheus datasource to Grafana for a workload cluster
+     * Called automatically when a workload cluster becomes READY
+     *
+     * NOTE: Loki datasource is NOT created per-cluster.
+     * A centralized Loki datasource is created once for the observability cluster.
+     * All workload clusters send logs to the same Loki instance, filtered by labels.
+     */
+    addClusterDatasources(cluster: ClusterEntity): Promise<void>;
+    /**
+     * Remove datasources when cluster is deleted
+     * Called automatically before cluster deletion
+     */
+    removeClusterDatasources(clusterId: string): Promise<void>;
+    /**
+     * Create Prometheus datasource in Grafana
+     * Returns the auto-generated UID
+     */
+    private createPrometheusDatasource;
+    /**
+     * Create centralized Loki datasource in Grafana
+     * This datasource is shared across all workload clusters
+     * Logs are filtered using labels: {cluster_name="...", service="...", etc.}
+     */
+    createCentralizedLokiDatasource(): Promise<void>;
+    private updateDatasource;
+    /**
+     * Delete datasource by UID
+     */
+    private deleteDatasource;
+    /**
+     * Initialize Grafana HTTP client with authentication
+     */
+    private initializeGrafanaClient;
+    /**
+     * Test Grafana connectivity
+     * Useful for health checks and debugging
+     */
+    testGrafanaConnection(): Promise<boolean>;
+    /**
+     * List all datasources in Grafana
+     * Useful for debugging and validation
+     */
+    listDatasources(): Promise<any[]>;
+    /**
+     * Find datasource UID by name
+     * Used when we need to update an existing datasource
+     */
+    private findDatasourceUidByName;
+    /**
+     * Save Grafana datasource UIDs to cluster metadata
+     * This allows the UIDs to be exposed via API and tracked over time
+     */
+    private saveGrafanaDatasourceUIDs;
+}