@flui-cloud/cli 0.0.1

package/lib/cli/src/config/defaults.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEPRECATION_STRATEGY = exports.CLI_DEFAULTS = void 0;
+exports.getRecommendedServerType = getRecommendedServerType;
+exports.getFallbackServerTypes = getFallbackServerTypes;
+exports.getHetznerEuRegions = getHetznerEuRegions;
+exports.getDefaultHetznerRegion = getDefaultHetznerRegion;
+exports.getScalewayEuRegions = getScalewayEuRegions;
+exports.getDefaultScalewayRegion = getDefaultScalewayRegion;
+exports.getEuRegions = getEuRegions;
+exports.getDefaultRegion = getDefaultRegion;
+exports.CLI_DEFAULTS = {
+    SERVER_TYPE_CACHE_TTL_HOURS: 12,
+    HETZNER_EU_REGIONS: ['nbg1', 'fsn1', 'hel1'],
+    DEFAULT_HETZNER_REGION: 'nbg1',
+    SCALEWAY_EU_REGIONS: ['fr-par', 'nl-ams', 'pl-waw'],
+    DEFAULT_SCALEWAY_REGION: 'fr-par',
+    FALLBACK_SERVER_TYPES: {
+        hetzner: ['cx23', 'cx33', 'cx32', 'cpx21', 'cx42', 'cpx31'],
+        scaleway: ['DEV1-M', 'DEV1-L', 'GP1-XS', 'GP1-S'],
+    },
+    RECOMMENDED_SERVER_TYPES: {
+        hetzner: 'cx23',
+        scaleway: 'DEV1-M',
+    },
+    MIN_SPECS: {
+        observability: {
+            cores: 2,
+            memory: 4,
+            disk: 40,
+        },
+        production: {
+            cores: 4,
+            memory: 8,
+            disk: 80,
+        },
+        development: {
+            cores: 2,
+            memory: 4,
+            disk: 20,
+        },
+    },
+};
+exports.DEPRECATION_STRATEGY = {
+    SHOW_WARNING: true,
+    AUTO_SELECT_ALTERNATIVE: false,
+    ALLOW_MANUAL_SELECTION: true,
+};
+function getRecommendedServerType(provider) {
+    return (exports.CLI_DEFAULTS.RECOMMENDED_SERVER_TYPES[provider] ||
+        exports.CLI_DEFAULTS.RECOMMENDED_SERVER_TYPES.hetzner);
+}
+function getFallbackServerTypes(provider) {
+    const types = exports.CLI_DEFAULTS.FALLBACK_SERVER_TYPES[provider] ||
+        exports.CLI_DEFAULTS.FALLBACK_SERVER_TYPES.hetzner;
+    return [...types];
+}
+function getHetznerEuRegions() {
+    return [...exports.CLI_DEFAULTS.HETZNER_EU_REGIONS];
+}
+function getDefaultHetznerRegion() {
+    return exports.CLI_DEFAULTS.DEFAULT_HETZNER_REGION;
+}
+function getScalewayEuRegions() {
+    return [...exports.CLI_DEFAULTS.SCALEWAY_EU_REGIONS];
+}
+function getDefaultScalewayRegion() {
+    return exports.CLI_DEFAULTS.DEFAULT_SCALEWAY_REGION;
+}
+function getEuRegions(provider) {
+    if (provider === 'scaleway')
+        return getScalewayEuRegions();
+    return getHetznerEuRegions();
+}
+function getDefaultRegion(provider) {
+    if (provider === 'scaleway')
+        return getDefaultScalewayRegion();
+    return getDefaultHetznerRegion();
+}

package/lib/cli/src/config/key-router.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Cloud provider keys recognized by `flui config set/get/remove`.
+ * Kept in sync with the prompts/credential logic; extend here when adding a new provider.
+ */
+export declare const SUPPORTED_PROVIDERS: readonly ["hetzner", "scaleway"];
+export type SupportedProvider = (typeof SUPPORTED_PROVIDERS)[number];
+export declare const SYSTEM_KEYS: readonly ["api-url"];
+export type SystemKey = (typeof SYSTEM_KEYS)[number];
+export type KeyKind = 'preference' | 'provider' | 'system' | 'unknown';
+/**
+ * Decide which storage area (preferences vs encrypted token vault) a `flui config` command
+ * should target, based purely on the key the user passed in.
+ *
+ * The dispatch is intentionally schema-driven so adding a new preference or provider does
+ * not require touching the user-facing commands.
+ */
+export declare function classifyKey(key: string): KeyKind;
+/**
+ * Multi-line description of every key the user can target — shown in error messages
+ * when an unknown key is passed to `flui config set/get/remove`.
+ */
+export declare function formatKnownKeys(): string;

package/lib/cli/src/config/key-router.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SYSTEM_KEYS = exports.SUPPORTED_PROVIDERS = void 0;
+exports.classifyKey = classifyKey;
+exports.formatKnownKeys = formatKnownKeys;
+const preferences_schema_1 = require("./preferences-schema");
+/**
+ * Cloud provider keys recognized by `flui config set/get/remove`.
+ * Kept in sync with the prompts/credential logic; extend here when adding a new provider.
+ */
+exports.SUPPORTED_PROVIDERS = ['hetzner', 'scaleway'];
+exports.SYSTEM_KEYS = ['api-url'];
+/**
+ * Decide which storage area (preferences vs encrypted token vault) a `flui config` command
+ * should target, based purely on the key the user passed in.
+ *
+ * The dispatch is intentionally schema-driven so adding a new preference or provider does
+ * not require touching the user-facing commands.
+ */
+function classifyKey(key) {
+    if ((0, preferences_schema_1.isPreferenceKey)(key))
+        return 'preference';
+    if (exports.SYSTEM_KEYS.includes(key.toLowerCase())) {
+        return 'system';
+    }
+    if (exports.SUPPORTED_PROVIDERS.includes(key.toLowerCase())) {
+        return 'provider';
+    }
+    return 'unknown';
+}
+/**
+ * Multi-line description of every key the user can target — shown in error messages
+ * when an unknown key is passed to `flui config set/get/remove`.
+ */
+function formatKnownKeys() {
+    const prefs = Object.values(preferences_schema_1.PREFERENCES)
+        .map((p) => `  - ${p.key} (preference) — ${p.description}`)
+        .join('\n');
+    const providers = exports.SUPPORTED_PROVIDERS.map((p) => {
+        const isCompound = p === 'scaleway';
+        return `  - ${p} (${isCompound ? 'access key + secret key' : 'provider token'})`;
+    }).join('\n');
+    const system = exports.SYSTEM_KEYS.map((k) => `  - ${k} (system override)`).join('\n');
+    return `Preferences:\n${prefs}\n\nProviders:\n${providers}\n\nSystem:\n${system}`;
+}

package/lib/cli/src/config/preferences-echo.d.ts

@@ -0,0 +1,9 @@
+import { PreferencesResolver, ResolvedPreference } from './preferences-resolver';
+/**
+ * Print resolved preferences (key, value, source) before a command performs work,
+ * so users always see what's about to be applied.
+ *
+ * Pass only the keys actually consumed by the command — not every preference in the schema —
+ * to keep the output focused.
+ */
+export declare function echoPreferences(resolved: ResolvedPreference[], resolver: PreferencesResolver): void;

package/lib/cli/src/config/preferences-echo.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.echoPreferences = echoPreferences;
+const chalk_1 = __importDefault(require("chalk"));
+const preferences_schema_1 = require("./preferences-schema");
+const SOURCE_LABELS = {
+    explicit: 'flag',
+    env: 'env',
+    project: 'project',
+    user: 'user',
+    default: 'default',
+    missing: 'missing',
+};
+/**
+ * Print resolved preferences (key, value, source) before a command performs work,
+ * so users always see what's about to be applied.
+ *
+ * Pass only the keys actually consumed by the command — not every preference in the schema —
+ * to keep the output focused.
+ */
+function echoPreferences(resolved, resolver) {
+    if (resolved.length === 0)
+        return;
+    const keyWidth = Math.max(...resolved.map((r) => String(r.key).length));
+    const valueWidth = Math.max(...resolved.map((r) => formatValue(r.value).length));
+    console.log(chalk_1.default.cyan('\nConfiguration in use:'));
+    for (const r of resolved) {
+        const def = preferences_schema_1.PREFERENCES[r.key];
+        const valStr = formatValue(r.value);
+        const sourceStr = formatSource(r);
+        console.log(`  ${chalk_1.default.bold(r.key.padEnd(keyWidth))}  ${valStr.padEnd(valueWidth)}  ${sourceStr}  ${chalk_1.default.dim(def.description)}`);
+    }
+    if (resolved.some((r) => r.source === 'project')) {
+        console.log(chalk_1.default.dim(`  ↳ project file: ${resolver.projectFilePath()}`));
+    }
+    console.log();
+}
+function formatValue(value) {
+    if (value === null || value === undefined)
+        return chalk_1.default.yellow('<unset>');
+    return String(value);
+}
+function formatSource(r) {
+    const label = SOURCE_LABELS[r.source];
+    switch (r.source) {
+        case 'explicit':
+        case 'env':
+            return chalk_1.default.green(`(${label})`);
+        case 'project':
+            return chalk_1.default.cyan(`(${label})`);
+        case 'user':
+            return chalk_1.default.blue(`(${label})`);
+        case 'default':
+            return chalk_1.default.dim(`(${label})`);
+        case 'missing':
+            return chalk_1.default.red(`(${label})`);
+    }
+}

package/lib/cli/src/config/preferences-resolver.d.ts

@@ -0,0 +1,43 @@
+import { ConfigStorage } from '../lib/config-storage';
+import { PreferenceKey } from './preferences-schema';
+/**
+ * Where a resolved preference value came from.
+ * Higher in the list = higher priority.
+ */
+export type PreferenceSource = 'explicit' | 'env' | 'project' | 'user' | 'default' | 'missing';
+export interface ResolvedPreference<T = unknown> {
+    key: PreferenceKey;
+    value: T | null;
+    source: PreferenceSource;
+}
+/**
+ * Resolves user preferences across all configured layers.
+ *
+ * Cascade (first hit wins):
+ *   explicit value > env var > project-local > user-global (active profile) > default > missing
+ *
+ * The project-local file may only override keys whose schema declares
+ * `projectOverridable: true`. Secret values (tokens, apiKey) are never read here.
+ */
+export declare class PreferencesResolver {
+    private readonly storage;
+    private readonly cwd;
+    private projectConfigCache;
+    constructor(storage?: ConfigStorage, cwd?: string);
+    resolve<T = string>(key: PreferenceKey, explicit?: T | null | undefined): ResolvedPreference<T>;
+    /**
+     * Resolve every key declared in the schema. Useful for `flui pref` listing.
+     */
+    resolveAll(): ResolvedPreference[];
+    /**
+     * Validate a candidate value against the schema. Returns null when ok.
+     */
+    static validate(key: PreferenceKey, value: string): string | null;
+    projectFilePath(): string;
+    /**
+     * Lazy-load the project-local file once per resolver instance.
+     * Returns null when missing or unreadable; throws only on malformed JSON
+     * (so config errors don't fail silently).
+     */
+    private readProjectFile;
+}

package/lib/cli/src/config/preferences-resolver.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreferencesResolver = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const config_storage_1 = require("../lib/config-storage");
+const preferences_schema_1 = require("./preferences-schema");
+const PROJECT_FILE = 'flui.config.json';
+/**
+ * Resolves user preferences across all configured layers.
+ *
+ * Cascade (first hit wins):
+ *   explicit value > env var > project-local > user-global (active profile) > default > missing
+ *
+ * The project-local file may only override keys whose schema declares
+ * `projectOverridable: true`. Secret values (tokens, apiKey) are never read here.
+ */
+class PreferencesResolver {
+    constructor(storage = new config_storage_1.ConfigStorage(), cwd = process.cwd()) {
+        this.storage = storage;
+        this.cwd = cwd;
+    }
+    resolve(key, explicit) {
+        const def = preferences_schema_1.PREFERENCES[key];
+        if (explicit !== undefined && explicit !== null && explicit !== '') {
+            return { key, value: explicit, source: 'explicit' };
+        }
+        const envValue = process.env[def.envVar];
+        if (envValue !== undefined && envValue !== '') {
+            return { key, value: envValue, source: 'env' };
+        }
+        if (def.projectOverridable) {
+            const projectValue = this.readProjectFile()?.[key];
+            if (projectValue !== undefined && projectValue !== '') {
+                return { key, value: projectValue, source: 'project' };
+            }
+        }
+        const userValue = this.storage.getPreference(key);
+        if (userValue !== undefined && userValue !== null && userValue !== '') {
+            return { key, value: userValue, source: 'user' };
+        }
+        if (def.defaultValue !== undefined) {
+            return {
+                key,
+                value: def.defaultValue,
+                source: 'default',
+            };
+        }
+        return { key, value: null, source: 'missing' };
+    }
+    /**
+     * Resolve every key declared in the schema. Useful for `flui pref` listing.
+     */
+    resolveAll() {
+        return Object.keys(preferences_schema_1.PREFERENCES).map((k) => this.resolve(k));
+    }
+    /**
+     * Validate a candidate value against the schema. Returns null when ok.
+     */
+    static validate(key, value) {
+        const def = preferences_schema_1.PREFERENCES[key];
+        if (def.allowedValues && !def.allowedValues.includes(value)) {
+            return `Allowed values: ${def.allowedValues.join(', ')}`;
+        }
+        if (def.validate) {
+            return def.validate(value);
+        }
+        return null;
+    }
+    projectFilePath() {
+        return (0, node_path_1.join)(this.cwd, PROJECT_FILE);
+    }
+    /**
+     * Lazy-load the project-local file once per resolver instance.
+     * Returns null when missing or unreadable; throws only on malformed JSON
+     * (so config errors don't fail silently).
+     */
+    readProjectFile() {
+        if (this.projectConfigCache !== undefined) {
+            return this.projectConfigCache;
+        }
+        const path = this.projectFilePath();
+        if (!(0, node_fs_1.existsSync)(path)) {
+            this.projectConfigCache = null;
+            return null;
+        }
+        try {
+            const parsed = JSON.parse((0, node_fs_1.readFileSync)(path, 'utf-8'));
+            if (typeof parsed !== 'object' || parsed === null) {
+                throw new Error('expected a JSON object at the root');
+            }
+            this.projectConfigCache = parsed;
+            return this.projectConfigCache;
+        }
+        catch (err) {
+            throw new Error(`Failed to parse project config ${path}: ${err.message}`);
+        }
+    }
+}
+exports.PreferencesResolver = PreferencesResolver;

package/lib/cli/src/config/preferences-schema.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Schema for user preferences resolved by the layered config system.
+ *
+ * Each entry declares everything the resolver needs:
+ * - where the value can come from (project file, env var, prompt),
+ * - how to validate it,
+ * - how to describe it to the user.
+ *
+ * Add a new preference here, then any command can consume it via
+ * `PreferencesResolver.resolve(key)` without touching command-specific flag wiring.
+ */
+export type PreferenceKey = 'email' | 'apiPath' | 'dashboardPath' | 'certificateMode';
+export interface PreferenceDefinition<T = string> {
+    /** Stable key — also used as JSON key in storage. */
+    key: PreferenceKey;
+    /** One-line human description shown in `flui pref` output and prompts. */
+    description: string;
+    /** Environment variable that overrides storage. */
+    envVar: string;
+    /** When true, project-local ./flui.config.json may override the user-global value. */
+    projectOverridable: boolean;
+    /** Default applied if no source provides a value (lowest priority). */
+    defaultValue?: T;
+    /** When true, the resolver requires a value and will prompt / fail if missing. */
+    required: boolean;
+    /** Optional enum of allowed values. */
+    allowedValues?: readonly T[];
+    /** Validator returning an error message or null when valid. */
+    validate?: (value: string) => string | null;
+}
+export declare const PREFERENCES: Record<PreferenceKey, PreferenceDefinition>;
+export declare function isPreferenceKey(value: string): value is PreferenceKey;

package/lib/cli/src/config/preferences-schema.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * Schema for user preferences resolved by the layered config system.
+ *
+ * Each entry declares everything the resolver needs:
+ * - where the value can come from (project file, env var, prompt),
+ * - how to validate it,
+ * - how to describe it to the user.
+ *
+ * Add a new preference here, then any command can consume it via
+ * `PreferencesResolver.resolve(key)` without touching command-specific flag wiring.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PREFERENCES = void 0;
+exports.isPreferenceKey = isPreferenceKey;
+exports.PREFERENCES = {
+    email: {
+        key: 'email',
+        description: 'Contact email used for ACME/Let\'s Encrypt and operational notifications',
+        envVar: 'FLUI_EMAIL',
+        projectOverridable: true,
+        required: true,
+        validate: (v) => (/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v) ? null : 'Not a valid email'),
+    },
+    apiPath: {
+        key: 'apiPath',
+        description: 'Path to the flui.api repo, used to locate the .env file written by env export-config',
+        envVar: 'FLUI_API_PATH',
+        projectOverridable: true,
+        defaultValue: '.',
+        required: false,
+    },
+    dashboardPath: {
+        key: 'dashboardPath',
+        description: 'Path to the flui.dashboard repo, used when syncing its config.json',
+        envVar: 'FLUI_DASHBOARD_PATH',
+        projectOverridable: true,
+        defaultValue: '../flui.dashboard',
+        required: false,
+    },
+    certificateMode: {
+        key: 'certificateMode',
+        description: 'Certificate issuance policy written into the dashboard config',
+        envVar: 'FLUI_CERTIFICATE_MODE',
+        projectOverridable: true,
+        defaultValue: 'production',
+        required: false,
+        allowedValues: ['staging', 'preflight', 'production'],
+    },
+};
+function isPreferenceKey(value) {
+    return value in exports.PREFERENCES;
+}

package/lib/cli/src/hooks/command_not_found.d.ts

@@ -0,0 +1,3 @@
+import { Hook } from '@oclif/core';
+declare const hook: Hook<'command_not_found'>;
+export default hook;

package/lib/cli/src/hooks/command_not_found.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function initCell(i, j) {
+    if (i === 0)
+        return j;
+    if (j === 0)
+        return i;
+    return 0;
+}
+function levenshtein(a, b) {
+    const dp = Array.from({ length: a.length + 1 }, (_, i) => Array.from({ length: b.length + 1 }, (_, j) => initCell(i, j)));
+    for (let i = 1; i <= a.length; i++) {
+        for (let j = 1; j <= b.length; j++) {
+            dp[i][j] =
+                a[i - 1] === b[j - 1]
+                    ? dp[i - 1][j - 1]
+                    : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+        }
+    }
+    return dp[a.length][b.length];
+}
+const hook = async function ({ config, id }) {
+    const input = id ?? '';
+    const allCommands = config.commands.map((c) => c.id);
+    let best = null;
+    let bestScore = Infinity;
+    for (const cmd of allCommands) {
+        const score = levenshtein(input, cmd);
+        if (score < bestScore) {
+            bestScore = score;
+            best = cmd;
+        }
+    }
+    const threshold = Math.max(3, Math.floor(input.length / 2));
+    const fmt = (id) => id.replaceAll(':', ' ');
+    if (best && bestScore <= threshold) {
+        process.stderr.write(`Command "flui ${fmt(input)}" not found. Did you mean "flui ${fmt(best)}"?\n`);
+    }
+    else {
+        process.stderr.write(`Command "flui ${fmt(input)}" not found. Run "flui --help" to see available commands.\n`);
+    }
+    process.exit(0);
+};
+exports.default = hook;

package/lib/cli/src/lib/api-client.d.ts

@@ -0,0 +1,58 @@
+import { NodeSizeDto } from '../../../src/modules/providers/dto/node-size.dto';
+/**
+ * HTTP client for Flui API communication
+ * Handles authentication, error handling, and request/response formatting
+ */
+export interface ApiClientConfig {
+    baseUrl: string;
+    timeout?: number;
+    apiKey?: string;
+}
+export declare class ApiError extends Error {
+    statusCode?: number;
+    details?: any;
+    constructor(message: string, statusCode?: number, details?: any);
+}
+export declare class ApiClient {
+    private readonly client;
+    private readonly baseUrl;
+    constructor(config: ApiClientConfig);
+    /**
+     * Normalize Axios errors to ApiError format
+     */
+    private normalizeError;
+    /**
+     * GET request
+     */
+    get<T>(path: string): Promise<T>;
+    /**
+     * POST request
+     */
+    post<T>(path: string, data?: any): Promise<T>;
+    /**
+     * PUT request
+     */
+    put<T>(path: string, data?: any): Promise<T>;
+    /**
+     * PATCH request
+     */
+    patch<T>(path: string, data?: any): Promise<T>;
+    /**
+     * DELETE request
+     */
+    delete<T>(path: string, config?: {
+        data?: unknown;
+    }): Promise<T>;
+    /**
+     * Get base URL
+     */
+    getBaseUrl(): string;
+    /**
+     * Get available node sizes/server types for a provider
+     */
+    getNodeSizes(provider: string, region?: string, skipCache?: boolean): Promise<NodeSizeDto[]>;
+    /**
+     * Clear node sizes cache for a provider
+     */
+    clearNodeSizesCache(provider: string): Promise<void>;
+}