@flui-cloud/cli 0.0.1

package/lib/cli/src/lib/services/cli-app.service.d.ts

@@ -0,0 +1,294 @@
+import { ApiClient } from '../api-client';
+export interface AppSummary {
+    id: string;
+    name: string;
+    slug: string;
+    status: string;
+    replicas: number;
+    kind: string;
+    exposure: string;
+    lastDeployedAt?: string;
+    clusterId: string;
+}
+export interface AppRuntime {
+    appId: string;
+    deploymentName: string;
+    namespace: string;
+    replicas: {
+        desired?: number;
+        ready?: number;
+        available?: number;
+        unavailable?: number;
+        updated?: number;
+    };
+    containers: Array<{
+        name: string;
+        image: string;
+        requests: {
+            cpu?: string;
+            memory?: string;
+        };
+        limits: {
+            cpu?: string;
+            memory?: string;
+        };
+        usage?: {
+            cpu?: string;
+            memory?: string;
+        };
+    }>;
+}
+export interface AppLogEntry {
+    timestamp: string;
+    level?: string;
+    message: string;
+    namespace?: string;
+    app?: string;
+    pod?: string;
+    container?: string;
+}
+export interface AppLogsResponse {
+    cluster_id: string;
+    count: number;
+    logs: AppLogEntry[];
+    queried_at: string;
+}
+export interface CrashDiagnosis {
+    id: string;
+    applicationId: string;
+    podName: string;
+    containerName: string | null;
+    category: string;
+    severity: string;
+    title: string;
+    explanation: string;
+    suggestedAction: Record<string, any>;
+    resolvedAt: string | null;
+    createdAt: string;
+}
+export interface AppMetricsResponse {
+    app_id: string;
+    app_name: string;
+    namespace: string;
+    cluster_id: string;
+    queried_at: string;
+    metrics: {
+        cpu: {
+            usage_cores: number | null;
+            requests_cores: number | null;
+            limits_cores: number | null;
+            utilization_percent: number | null;
+        };
+        memory: {
+            usage_bytes: number | null;
+            requests_bytes: number | null;
+            limits_bytes: number | null;
+            utilization_percent: number | null;
+        };
+        network: {
+            receive_bytes_rate: number | null;
+            transmit_bytes_rate: number | null;
+        };
+        status: {
+            replicas_desired: number | null;
+            replicas_ready: number | null;
+            replicas_unavailable: number | null;
+            ready_ratio: number | null;
+            up: number | null;
+            restart_total: number | null;
+            restart_rate_1h: number | null;
+        };
+        pods: Array<{
+            phase: string;
+            count: number;
+        }>;
+        replicas: Array<Record<string, unknown>>;
+        health?: {
+            status: string;
+            message?: string;
+        } | null;
+    };
+}
+export interface AppLogsOptions {
+    app?: string;
+    namespace?: string;
+    level?: string;
+    tail?: number;
+    search?: string;
+}
+export interface AppDetail {
+    id: string;
+    name: string;
+    slug: string;
+    status: string;
+    catalogInstallId?: string;
+    catalogSlug?: string;
+    systemProtected?: boolean;
+}
+export interface UninstallResult {
+    id: string;
+    status: string;
+}
+export interface DeleteAppResult {
+    operation: {
+        id: string;
+        status: string;
+        totalSteps: number;
+        operationType: string;
+    };
+}
+export interface AppBuild {
+    id: string;
+    applicationId: string | null;
+    provider: 'IN_CLUSTER_AGENT' | 'GITHUB_ACTIONS' | 'RAILPACK' | 'DOCKERFILE';
+    status: 'PENDING' | 'CLONING' | 'ANALYZING' | 'BUILDING' | 'PUSHING' | 'COMPLETED' | 'FAILED' | 'CANCELLED';
+    branch: string;
+    commitSha?: string;
+    imageRef?: string;
+    externalRunId?: string;
+    externalUrl?: string;
+    logsUrl?: string;
+    errorMessage?: string;
+    startedAt?: string;
+    completedAt?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ApplicationRelease {
+    applicationId: string;
+    operationId: string;
+    status: 'IN_PROGRESS' | 'SUCCEEDED' | 'FAILED' | 'ROLLED_BACK';
+    imageRef?: string | null;
+    previousImageRef?: string | null;
+    buildId?: string | null;
+    failureReason?: string | null;
+    startedAt: string;
+    completedAt?: string | null;
+}
+export interface AvailableVersion {
+    tag: string;
+    imageRef: string;
+    versionId?: number;
+    allTags?: string[];
+    isCurrentlyDeployed: boolean;
+    createdAt?: string;
+    digest?: string;
+    deployHint?: string;
+    platforms?: string[];
+    lastRelease?: ApplicationRelease | null;
+    releaseCount: number;
+    isLatestRelease: boolean;
+}
+export interface AvailableVersionsResponse {
+    sourceType: string;
+    currentImageRef: string | null;
+    versions: AvailableVersion[];
+    nextPage: number | null;
+    allowedPatterns: string[] | null;
+}
+export declare class CliAppService {
+    private readonly apiClient;
+    private readonly clusterId;
+    constructor(apiClient: ApiClient, clusterId: string);
+    static create(clusterId: string): Promise<CliAppService>;
+    listApps(): Promise<AppSummary[]>;
+    getAppByName(name: string): Promise<AppSummary>;
+    getRuntime(appId: string): Promise<AppRuntime>;
+    getLogs(options: AppLogsOptions): Promise<AppLogsResponse>;
+    scale(appId: string, replicas: number): Promise<AppRuntime>;
+    restart(appId: string): Promise<void>;
+    stop(appId: string): Promise<void>;
+    start(appId: string): Promise<void>;
+    getCrashes(appId: string): Promise<CrashDiagnosis[]>;
+    getCrash(appId: string, id: string): Promise<CrashDiagnosis>;
+    dismissCrash(appId: string, id: string): Promise<CrashDiagnosis>;
+    getMetrics(appId: string): Promise<AppMetricsResponse>;
+    getAppDetail(appId: string): Promise<AppDetail>;
+    uninstall(catalogInstallId: string): Promise<UninstallResult>;
+    deleteApp(appId: string): Promise<DeleteAppResult>;
+    getInstallStatus(catalogInstallId: string): Promise<{
+        id: string;
+        status: string;
+        errorMessage?: string;
+    }>;
+    listBuilds(appId: string): Promise<AppBuild[]>;
+    getLatestBuild(appId: string): Promise<AppBuild | null>;
+    getBuild(buildId: string): Promise<AppBuild>;
+    refreshBuild(buildId: string): Promise<AppBuild>;
+    cancelBuild(buildId: string): Promise<void>;
+    deployFromBuild(appId: string, buildId: string): Promise<unknown>;
+    getCurrentRelease(appId: string): Promise<ApplicationRelease | null>;
+    listReleases(appId: string): Promise<ApplicationRelease[]>;
+    listAvailableVersions(appId: string): Promise<AvailableVersionsResponse>;
+    redeployTag(appId: string, tag: string): Promise<unknown>;
+    deleteImageVersion(appId: string, versionId: number, options?: {
+        force?: boolean;
+    }): Promise<{
+        deleted: boolean;
+    }>;
+    createAppSnapshot(appId: string, body?: {
+        volumeName?: string;
+        description?: string;
+    }): Promise<SnapshotResponse>;
+    listAppSnapshots(appId: string): Promise<SnapshotResponse[]>;
+    deleteAppSnapshot(appId: string, snapshotId: string): Promise<{
+        operationId: string;
+    } | void>;
+    listClusterSnapshots(): Promise<SnapshotResponse[]>;
+    restoreAppSnapshot(appId: string, snapshotId: string): Promise<{
+        newPvcName: string;
+        sourceSnapshotId: string;
+    }>;
+    swapAppVolume(appId: string, volumeName: string, newClaimName: string): Promise<unknown>;
+    createAppBackup(appId: string, body: {
+        volumeName?: string;
+        description?: string;
+        destination: BackupDestinationInput;
+    }): Promise<BackupResponse>;
+    deleteAppBackup(appId: string, exportId: string, destination: BackupDestinationInput): Promise<void>;
+}
+export interface SnapshotResponse {
+    exportId: string;
+    sink: 'pvc-clone' | 's3-archive';
+    namespace: string;
+    sourcePvcName?: string;
+    appId?: string;
+    sizeGb?: number;
+    actualBytes?: number;
+    createdAt: string;
+    ready: boolean;
+    labels: Record<string, string>;
+    provider: string;
+    providerCapabilities: {
+        pvcCloneSupportsCheapRetention: boolean;
+        s3ArchiveSupportsCheapRetention: boolean;
+        pvcClonePricePerGbMonthEur: number | null;
+        s3ArchivePricePerGbMonthEur: number | null;
+    };
+}
+export interface BackupDestinationInput {
+    bucket: string;
+    endpoint: string;
+    region: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    keyPrefix?: string;
+}
+export interface BackupResponse {
+    exportId: string;
+    appId: string;
+    namespace: string;
+    sourcePvcName: string;
+    sizeGb: number;
+    actualBytes?: number;
+    createdAt: string;
+    ready: boolean;
+    destination: {
+        bucket: string;
+        endpoint: string;
+        region: string;
+        keyPrefix?: string;
+    };
+    provider: string;
+    providerCapabilities: SnapshotResponse['providerCapabilities'];
+}

package/lib/cli/src/lib/services/cli-app.service.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliAppService = void 0;
+const api_client_1 = require("../api-client");
+const config_storage_1 = require("../config-storage");
+class CliAppService {
+    constructor(apiClient, clusterId) {
+        this.apiClient = apiClient;
+        this.clusterId = clusterId;
+    }
+    static async create(clusterId) {
+        const configStorage = new config_storage_1.ConfigStorage();
+        const apiUrl = configStorage.getApiUrlOrThrow();
+        const apiKey = configStorage.getApiKey();
+        if (!apiKey) {
+            throw new Error('Not logged in. Run `flui auth login` first.');
+        }
+        const apiClient = new api_client_1.ApiClient({ baseUrl: apiUrl, apiKey });
+        return new CliAppService(apiClient, clusterId);
+    }
+    async listApps() {
+        return this.apiClient.get(`/clusters/${this.clusterId}/applications`);
+    }
+    async getAppByName(name) {
+        const apps = await this.listApps();
+        const app = apps.find((a) => a.name.toLowerCase() === name.toLowerCase() ||
+            a.slug.toLowerCase() === name.toLowerCase());
+        if (!app) {
+            throw new Error(`App "${name}" not found in cluster.`);
+        }
+        return app;
+    }
+    async getRuntime(appId) {
+        return this.apiClient.get(`/applications/${appId}/runtime`);
+    }
+    async getLogs(options) {
+        const params = new URLSearchParams();
+        if (options.app)
+            params.append('app', options.app);
+        if (options.namespace)
+            params.append('namespace', options.namespace);
+        if (options.level)
+            params.append('level', options.level);
+        if (options.tail)
+            params.append('tail', String(options.tail));
+        if (options.search)
+            params.append('search', options.search);
+        const qs = params.toString();
+        const qsSuffix = qs ? `?${qs}` : '';
+        return this.apiClient.get(`/observability/clusters/${this.clusterId}/apps/logs${qsSuffix}`);
+    }
+    async scale(appId, replicas) {
+        return this.apiClient.patch(`/applications/${appId}/replicas`, {
+            replicas,
+        });
+    }
+    async restart(appId) {
+        return this.apiClient.post(`/applications/${appId}/restart`);
+    }
+    async stop(appId) {
+        return this.apiClient.post(`/applications/${appId}/stop`);
+    }
+    async start(appId) {
+        return this.apiClient.post(`/applications/${appId}/start`);
+    }
+    async getCrashes(appId) {
+        return this.apiClient.get(`/applications/${appId}/crash-diagnoses`);
+    }
+    async getCrash(appId, id) {
+        return this.apiClient.get(`/applications/${appId}/crash-diagnoses/${id}`);
+    }
+    async dismissCrash(appId, id) {
+        return this.apiClient.post(`/applications/${appId}/crash-diagnoses/${id}/dismiss`);
+    }
+    async getMetrics(appId) {
+        return this.apiClient.get(`/applications/${appId}/metrics`);
+    }
+    async getAppDetail(appId) {
+        return this.apiClient.get(`/applications/${appId}`);
+    }
+    async uninstall(catalogInstallId) {
+        return this.apiClient.delete(`/catalog/installs/${catalogInstallId}`);
+    }
+    async deleteApp(appId) {
+        return this.apiClient.delete(`/applications/${appId}`);
+    }
+    async getInstallStatus(catalogInstallId) {
+        return this.apiClient.get(`/catalog/installs/${catalogInstallId}`);
+    }
+    // ── Builds ──────────────────────────────────────────────────────────────
+    async listBuilds(appId) {
+        return this.apiClient.get(`/applications/${appId}/builds`);
+    }
+    async getLatestBuild(appId) {
+        try {
+            return await this.apiClient.get(`/applications/${appId}/builds/latest`);
+        }
+        catch (err) {
+            if (err?.status === 404)
+                return null;
+            throw err;
+        }
+    }
+    async getBuild(buildId) {
+        return this.apiClient.get(`/applications/builds/${buildId}`);
+    }
+    async refreshBuild(buildId) {
+        return this.apiClient.post(`/applications/builds/${buildId}/refresh`);
+    }
+    async cancelBuild(buildId) {
+        return this.apiClient.post(`/applications/builds/${buildId}/cancel`);
+    }
+    async deployFromBuild(appId, buildId) {
+        return this.apiClient.post(`/applications/${appId}/builds/${buildId}/deploy`);
+    }
+    // ── Releases ────────────────────────────────────────────────────────────
+    async getCurrentRelease(appId) {
+        return this.apiClient.get(`/applications/${appId}/release`);
+    }
+    async listReleases(appId) {
+        const res = await this.apiClient.get(`/applications/${appId}/releases`);
+        return res.releases;
+    }
+    // ── Versions / Images ───────────────────────────────────────────────────
+    async listAvailableVersions(appId) {
+        return this.apiClient.get(`/applications/${appId}/available-versions`);
+    }
+    async redeployTag(appId, tag) {
+        return this.apiClient.post(`/image-registry/apps/${appId}/ghcr/${encodeURIComponent(tag)}/deploy`);
+    }
+    async deleteImageVersion(appId, versionId, options) {
+        const qs = options?.force ? '?force=true' : '';
+        return this.apiClient.delete(`/image-registry/apps/${appId}/ghcr/${versionId}${qs}`);
+    }
+    // ── Volume snapshots ────────────────────────────────────
+    async createAppSnapshot(appId, body = {}) {
+        return this.apiClient.post(`/applications/${appId}/snapshots`, body);
+    }
+    async listAppSnapshots(appId) {
+        return this.apiClient.get(`/applications/${appId}/snapshots`);
+    }
+    async deleteAppSnapshot(appId, snapshotId) {
+        return this.apiClient.delete(`/applications/${appId}/snapshots/${encodeURIComponent(snapshotId)}`);
+    }
+    async listClusterSnapshots() {
+        return this.apiClient.get(`/clusters/${this.clusterId}/snapshots`);
+    }
+    async restoreAppSnapshot(appId, snapshotId) {
+        return this.apiClient.post(`/applications/${appId}/snapshots/${encodeURIComponent(snapshotId)}/restore`, {});
+    }
+    async swapAppVolume(appId, volumeName, newClaimName) {
+        return this.apiClient.post(`/applications/${appId}/volumes/${encodeURIComponent(volumeName)}/swap`, { newClaimName });
+    }
+    // ── Volume backups (s3-archive sink) ────────────────────────
+    async createAppBackup(appId, body) {
+        return this.apiClient.post(`/applications/${appId}/backups`, body);
+    }
+    async deleteAppBackup(appId, exportId, destination) {
+        await this.apiClient.delete(`/applications/${appId}/backups/${encodeURIComponent(exportId)}`, { data: { destination } });
+    }
+}
+exports.CliAppService = CliAppService;

package/lib/cli/src/lib/services/cli-node.service.d.ts

@@ -0,0 +1,43 @@
+import { ApiClient } from '../api-client';
+export interface NodeSummary {
+    id: string;
+    serverName: string;
+    nodeType: 'master' | 'worker';
+    ipAddress: string;
+    status: string;
+    providerResourceId?: string;
+    createdAt: string;
+    metadata?: Record<string, any>;
+}
+export interface AddWorkerResult {
+    operation_id: string;
+    resource_id: string;
+    status: string;
+    estimated_duration: string;
+    created_at: string;
+}
+export interface RemoveWorkerResult {
+    operation_id: string;
+    resource_id: string;
+    status: string;
+    estimated_duration: string;
+    created_at: string;
+}
+export interface OperationStatus {
+    id: string;
+    status: 'PENDING' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED' | 'CANCELLED';
+    currentStepIndex: number;
+    totalSteps: number;
+    currentStepProgress: number;
+    metadata?: Record<string, any>;
+}
+export declare class CliNodeService {
+    private readonly apiClient;
+    private readonly clusterId;
+    constructor(apiClient: ApiClient, clusterId: string);
+    static create(clusterId: string): Promise<CliNodeService>;
+    listNodes(): Promise<NodeSummary[]>;
+    addWorkers(count: number): Promise<AddWorkerResult>;
+    removeWorker(nodeId: string): Promise<RemoveWorkerResult>;
+    getOperationStatus(operationId: string): Promise<OperationStatus>;
+}

package/lib/cli/src/lib/services/cli-node.service.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliNodeService = void 0;
+const api_client_1 = require("../api-client");
+const config_storage_1 = require("../config-storage");
+class CliNodeService {
+    constructor(apiClient, clusterId) {
+        this.apiClient = apiClient;
+        this.clusterId = clusterId;
+    }
+    static async create(clusterId) {
+        const configStorage = new config_storage_1.ConfigStorage();
+        const apiUrl = configStorage.getApiUrlOrThrow();
+        const apiKey = configStorage.getApiKey();
+        if (!apiKey) {
+            throw new Error('Not logged in. Run `flui auth login` first.');
+        }
+        const apiClient = new api_client_1.ApiClient({ baseUrl: apiUrl, apiKey });
+        return new CliNodeService(apiClient, clusterId);
+    }
+    async listNodes() {
+        return this.apiClient.get(`/infrastructure/clusters/${this.clusterId}/nodes`);
+    }
+    async addWorkers(count) {
+        return this.apiClient.post(`/infrastructure/clusters/${this.clusterId}/workers`, { count });
+    }
+    async removeWorker(nodeId) {
+        return this.apiClient.delete(`/infrastructure/clusters/${this.clusterId}/workers/${nodeId}`);
+    }
+    async getOperationStatus(operationId) {
+        return this.apiClient.get(`/infrastructure/operations/${operationId}`);
+    }
+}
+exports.CliNodeService = CliNodeService;

package/lib/cli/src/lib/services/provider-sync.service.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Provider sync service - Synchronizes CLI provider configuration to API
+ */
+export declare enum CloudProvider {
+    HETZNER = "hetzner",
+    SCALEWAY = "scaleway"
+}
+export declare enum CredentialType {
+    API_KEY = "api_key",
+    ACCESS_KEY_SECRET = "access_key_secret",
+    USER_PASSWORD = "user_password",
+    BEARER_TOKEN = "bearer_token"
+}
+export interface ProviderCredentialsDto {
+    provider: CloudProvider;
+    type: CredentialType;
+    apiKey?: string;
+    accessKey?: string;
+    secretKey?: string;
+    username?: string;
+    password?: string;
+    clientId?: string;
+    clientSecret?: string;
+    bearerToken?: string;
+}
+export interface ConfigureProviderDto {
+    provider: CloudProvider;
+    credentials: ProviderCredentialsDto;
+    enabledRegions: string[];
+    additionalConfig?: Record<string, any>;
+}
+export interface ProviderConfiguration {
+    id: string;
+    provider: CloudProvider;
+    status: string;
+    enabledRegions: string[];
+    configuration: Record<string, any>;
+    isActive: boolean;
+    lastHealthCheck?: Date;
+    metadata: Record<string, any>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface ProviderSyncResult {
+    success: boolean;
+    message: string;
+    providerConfiguration?: ProviderConfiguration;
+    error?: string;
+}
+export declare class ProviderSyncService {
+    private readonly configStorage;
+    private apiClient;
+    constructor(apiUrl: string);
+    setApiKey(apiKey: string): void;
+    /**
+     * Check if provider exists in API
+     */
+    checkProviderExists(provider: CloudProvider): Promise<boolean>;
+    /**
+     * Get provider configuration from API
+     */
+    getProviderConfiguration(provider: CloudProvider): Promise<ProviderConfiguration | null>;
+    /**
+     * Validate provider is supported
+     */
+    private validateProvider;
+    /**
+     * Get credential type for provider
+     */
+    private getCredentialType;
+    /**
+     * Get regions to enable for provider
+     */
+    private getRegionsToEnable;
+    /**
+     * Build ConfigureProviderDto from CLI config
+     */
+    private buildConfigureDto;
+    /**
+     * Sync provider from CLI to API
+     */
+    syncProvider(providerName: string, options?: {
+        regions?: string[];
+        force?: boolean;
+    }): Promise<ProviderSyncResult>;
+    /**
+     * Get API client base URL
+     */
+    getApiUrl(): string;
+}