@marteye/studio-cli/dist/commands/config.js

CLI for MartEye Studio API

'use strict';

var chalk = require('chalk');
var commander = require('commander');
var inquirer = require('inquirer');
var configManager = require('../config/config-manager.js');
var output = require('../utils/output.js');

function configCommand() {
    const config = new commander.Command("config").description("Manage CLI configuration");
    config
        .command("init")
        .description("Initialize configuration")
        .action(async () => {
        const answers = await inquirer.prompt([
            {
                type: "input",
                name: "apiKey",
                message: "Enter your API key:",
                validate: (input) => input.length > 0 || "API key is required",
            },
            {
                type: "input",
                name: "baseUrl",
                message: "API base URL:",
                default: "https://app.marteyestudio.com/api",
            },
            {
                type: "list",
                name: "outputFormat",
                message: "Default output format:",
                choices: ["json", "yaml", "table", "csv"],
                default: "json",
            },
        ]);
        const config = {
            defaultProfile: "default",
            profiles: {
                default: {
                    apiKey: answers.apiKey,
                    baseUrl: answers.baseUrl,
                    output: answers.outputFormat,
                },
            },
            preferences: {
                color: true,
                cache: false,
                cacheExpiry: 300,
            },
        };
        configManager.saveConfig(config);
        output.success("Configuration initialized successfully");
    });
    config
        .command("set <key> <value>")
        .description("Set configuration value in the active profile")
        .option("--global", "Set value globally instead of in active profile")
        .action((key, value, options) => {
        try {
            // Parse value if it looks like JSON
            let parsedValue = value;
            if (value === "true")
                parsedValue = true;
            else if (value === "false")
                parsedValue = false;
            else if (!isNaN(Number(value)))
                parsedValue = Number(value);
            const cfg = configManager.loadConfig();
            // Known profile-specific keys
            const profileKeys = ["apiKey", "baseUrl", "timeout", "debug", "output"];
            // If the key is a profile setting and not using --global, set it in the active profile
            if (profileKeys.includes(key) && !options.global) {
                // Determine active profile
                const activeProfile = cfg.defaultProfile || "default";
                // Ensure profiles object exists
                if (!cfg.profiles) {
                    cfg.profiles = {};
                }
                // Ensure active profile exists
                if (!cfg.profiles[activeProfile]) {
                    cfg.profiles[activeProfile] = {};
                }
                // Set the value in the active profile
                cfg.profiles[activeProfile][key] = parsedValue;
                configManager.saveConfig(cfg);
                output.success(`Set ${key} = ${parsedValue} in profile '${activeProfile}'`);
            }
            else {
                // Set as a global/root value or handle nested paths
                configManager.setConfigValue(key, parsedValue);
                output.success(`Set ${key} = ${parsedValue}`);
            }
        }
        catch (err) {
            output.error("Failed to set configuration value", err.message);
            process.exit(1);
        }
    });
    config
        .command("get <key>")
        .description("Get configuration value")
        .action((key) => {
        const value = configManager.getConfigValue(key);
        if (value !== undefined) {
            console.log(value);
        }
        else {
            output.warning(`Configuration key '${key}' not found`);
            process.exit(1);
        }
    });
    config
        .command("list")
        .description("List all configurations")
        .action((_options, command) => {
        const globalOptions = command.parent?.opts() || {};
        const cfg = configManager.loadConfig();
        output.output(cfg, globalOptions);
    });
    config
        .command("use <profile>")
        .description("Switch to a configuration profile")
        .action((profile) => {
        try {
            configManager.setDefaultProfile(profile);
            output.success(`Switched to profile '${profile}'`);
        }
        catch (err) {
            output.error(err.message);
            process.exit(1);
        }
    });
    config
        .command("create-profile <name>")
        .description("Create a new configuration profile")
        .action(async (name) => {
        const answers = await inquirer.prompt([
            {
                type: "input",
                name: "apiKey",
                message: "Enter API key for this profile:",
                validate: (input) => input.length > 0 || "API key is required",
            },
            {
                type: "input",
                name: "baseUrl",
                message: "API base URL:",
                default: "https://app.marteyestudio.com/api",
            },
            {
                type: "number",
                name: "timeout",
                message: "Request timeout (ms):",
                default: 10000,
            },
            {
                type: "confirm",
                name: "debug",
                message: "Enable debug mode?",
                default: false,
            },
            {
                type: "list",
                name: "output",
                message: "Default output format:",
                choices: ["json", "yaml", "table", "csv"],
                default: "json",
            },
        ]);
        configManager.createProfile(name, answers);
        output.success(`Profile '${name}' created successfully`);
        const setAsDefault = await inquirer.prompt([
            {
                type: "confirm",
                name: "setDefault",
                message: "Set as default profile?",
                default: false,
            },
        ]);
        if (setAsDefault.setDefault) {
            configManager.setDefaultProfile(name);
            output.success(`Profile '${name}' set as default`);
        }
    });
    config
        .command("delete-profile <name>")
        .description("Delete a configuration profile")
        .option("--confirm", "Skip confirmation prompt")
        .action(async (name, options) => {
        if (!options.confirm) {
            const answer = await inquirer.prompt([
                {
                    type: "confirm",
                    name: "confirm",
                    message: `Are you sure you want to delete profile '${name}'?`,
                    default: false,
                },
            ]);
            if (!answer.confirm) {
                console.log("Cancelled");
                return;
            }
        }
        configManager.deleteProfile(name);
        output.success(`Profile '${name}' deleted`);
    });
    config
        .command("list-profiles")
        .description("List all configuration profiles")
        .action(() => {
        const profiles = configManager.listProfiles();
        const cfg = configManager.loadConfig();
        if (profiles.length === 0) {
            output.warning("No profiles configured");
        }
        else {
            console.log(chalk.bold("Available profiles:"));
            profiles.forEach((name) => {
                const isDefault = cfg.defaultProfile === name;
                const marker = isDefault ? chalk.green(" (default)") : "";
                console.log(`  - ${name}${marker}`);
            });
        }
    });
    return config;
}

exports.configCommand = configCommand;
//# sourceMappingURL=config.js.map