@agentuity/cli 0.0.51 → 0.0.52

package/dist/cli.js

@@ -0,0 +1,822 @@
+import { Command } from 'commander';
+import { showBanner } from './banner';
+import { requireAuth, optionalAuth, requireOrg, optionalOrg as selectOptionalOrg } from './auth';
+import { listRegions } from '@agentuity/server';
+import enquirer from 'enquirer';
+import * as tui from './tui';
+import { parseArgsSchema, parseOptionsSchema, buildValidationInput } from './schema-parser';
+import { defaultProfileName, loadProjectConfig } from './config';
+import { APIClient, getAPIBaseURL } from './api';
+import { ErrorCode, ExitCode, createError, exitWithError } from './errors';
+import { getCommand } from './command-prefix';
+import { isValidateMode, outputValidation } from './output';
+function createAPIClient(baseCtx, config) {
+    try {
+        const apiUrl = getAPIBaseURL(config);
+        const apiClient = new APIClient(apiUrl, baseCtx.logger, config);
+        if (!apiClient) {
+            throw new Error('APIClient constructor returned null/undefined');
+        }
+        if (typeof apiClient.request !== 'function') {
+            throw new Error('APIClient instance is missing request method');
+        }
+        return apiClient;
+    }
+    catch (error) {
+        baseCtx.logger.error('Failed to create API client:', error);
+        throw new Error(`API client initialization failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Execute handler or output validation result based on mode
+ */
+async function executeOrValidate(ctx, commandName, handler) {
+    if (isValidateMode(ctx.options)) {
+        // In validate mode, just output success (validation already passed via Zod)
+        const result = {
+            valid: true,
+            command: commandName,
+        };
+        outputValidation(result, ctx.options);
+    }
+    else if (handler) {
+        // Normal execution
+        await handler(ctx);
+    }
+}
+/**
+ * Handle validation error - output structured result in validate mode, otherwise log and exit
+ */
+function handleValidationError(error, commandName, baseCtx) {
+    if (error && typeof error === 'object' && 'issues' in error) {
+        const issues = error.issues;
+        if (isValidateMode(baseCtx.options)) {
+            // In validate mode, output structured validation result
+            const result = {
+                valid: false,
+                command: commandName,
+                errors: issues.map((issue) => ({
+                    field: issue.path?.length ? issue.path.join('.') : 'unknown',
+                    message: issue.message,
+                })),
+            };
+            outputValidation(result, baseCtx.options);
+            process.exit(ExitCode.VALIDATION_ERROR);
+        }
+        else {
+            // Use centralized error handling
+            exitWithError({
+                code: ErrorCode.VALIDATION_FAILED,
+                message: 'Validation error',
+                details: {
+                    issues: issues.map((issue) => ({
+                        field: issue.path?.length ? issue.path.join('.') : 'unknown',
+                        message: issue.message,
+                    })),
+                },
+            }, baseCtx.logger, baseCtx.options.errorFormat ?? 'text');
+        }
+    }
+    throw error;
+}
+function normalizeReqs(def) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const d = def;
+    const requires = d.requires;
+    const optional = d.optional;
+    const requiresAuth = requires?.auth === true;
+    const optionalAuthValue = optional?.auth;
+    const optionalAuth = optionalAuthValue === true ? 'Continue without authentication' : optionalAuthValue || false;
+    const requiresProject = requires?.project === true;
+    const optionalProject = optional?.project === true;
+    const requiresOrg = requires?.org === true;
+    const optionalOrg = optional?.org === true;
+    const requiresRegions = requires?.regions === true;
+    const requiresRegion = requires?.region === true;
+    const optionalRegion = optional?.region === true;
+    // Implicitly require apiClient if org or region is required or optional
+    const requiresAPIClient = requires?.apiClient === true ||
+        requiresOrg ||
+        optionalOrg ||
+        requiresRegion ||
+        optionalRegion ||
+        requiresRegions;
+    return {
+        requiresAuth,
+        optionalAuth,
+        requiresProject,
+        optionalProject,
+        requiresAPIClient,
+        requiresOrg,
+        optionalOrg,
+        requiresRegions,
+        requiresRegion,
+        optionalRegion,
+    };
+}
+function handleProjectConfigError(error, requiresProject, logger, errorFormat) {
+    if (requiresProject &&
+        error &&
+        typeof error === 'object' &&
+        'name' in error &&
+        error.name === 'ProjectConfigNotFoundExpection') {
+        exitWithError(createError(ErrorCode.PROJECT_NOT_FOUND, 'Invalid project folder', undefined, [
+            'Use --dir to specify a different directory',
+            'Change to a directory containing agentuity.json',
+            `Run "${getCommand('project create')}" to create a new project`,
+        ]), logger, errorFormat ?? 'text');
+    }
+    throw error;
+}
+export async function createCLI(version) {
+    const program = new Command();
+    program
+        .name('agentuity')
+        .version(version, '-V, --version', 'Display version')
+        .helpOption('-h, --help=[json]', 'Display help (with optional JSON output)')
+        .allowUnknownOption(false)
+        .allowExcessArguments(false)
+        .showHelpAfterError(true);
+    program
+        .option('--config <path>', 'Config file path')
+        .option('--log-level <level>', 'Log level', process.env.AGENTUITY_LOG_LEVEL ?? 'info')
+        .option('--log-timestamp', 'Show timestamps in log output', false)
+        .option('--no-log-prefix', 'Hide log level prefixes', true)
+        .option('--org-id <id>', 'Use a specific organization when performing operations', process.env.AGENTUITY_CLOUD_ORG_ID)
+        .option('--color-scheme <scheme>', 'Color scheme: light or dark')
+        .option('--color <mode>', 'Color output: auto, always, never', 'auto')
+        .option('--error-format <format>', 'Error output format: json or text', 'text')
+        .option('--json', 'Output in JSON format (machine-readable)', false)
+        .option('--quiet', 'Suppress non-essential output', false)
+        .option('--no-progress', 'Disable progress indicators', false)
+        .option('--explain', 'Show what the command would do without executing', false)
+        .option('--dry-run', 'Execute command without making changes', false)
+        .option('--validate', 'Validate arguments and options without executing', false);
+    const skipVersionCheckOption = program.createOption('--skip-version-check', 'Skip version compatibility check (dev only)');
+    skipVersionCheckOption.hideHelp();
+    program.addOption(skipVersionCheckOption);
+    program.action(() => {
+        showBanner(version);
+        program.help();
+    });
+    // Handle unknown commands
+    program.on('command:*', (operands) => {
+        const unknownCommand = operands[0];
+        console.error(`error: unknown command '${unknownCommand}'`);
+        console.error();
+        const availableCommands = program.commands.map((cmd) => cmd.name());
+        if (availableCommands.length > 0) {
+            console.error('Available commands:');
+            availableCommands.forEach((name) => {
+                console.error(`  ${name}`);
+            });
+        }
+        console.error();
+        console.error(`Run '${getCommand('--help')}' for usage information.`);
+        process.exit(1);
+    });
+    // Custom error handling for argument/command parsing errors
+    program.configureOutput({
+        outputError: (str, write) => {
+            // Intercept commander.js error messages
+            if (str.includes('too many arguments') || str.includes('unknown command')) {
+                // Extract potential command name from error context
+                const match = str.match(/got (\d+)/);
+                if (match) {
+                    write(`error: unknown command or subcommand\n`);
+                    write(`\nRun '${getCommand('--help')}' for available commands.\n`);
+                }
+                else {
+                    write(str);
+                }
+            }
+            else {
+                write(str);
+            }
+        },
+    });
+    // Configure help to show only main command names, not aliases
+    program.configureHelp({
+        subcommandTerm: (cmd) => cmd.name(),
+    });
+    return program;
+}
+async function getRegion(regions) {
+    if (regions.length === 1) {
+        return regions[0].region;
+    }
+    else {
+        const response = await enquirer.prompt({
+            type: 'select',
+            name: 'region',
+            message: 'Select a cloud region:',
+            choices: regions.map((r) => ({
+                name: r.region,
+                message: `${r.description.padEnd(15, ' ')} ${tui.muted(r.region)}`,
+            })),
+        });
+        return response.region;
+    }
+}
+async function resolveRegion(opts) {
+    const { options, apiClient, logger, required } = opts;
+    // Fetch regions
+    const regions = await listRegions(apiClient);
+    // No regions available
+    if (regions.length === 0) {
+        if (required) {
+            const errorFormat = options.errorFormat;
+            exitWithError(createError(ErrorCode.NO_REGIONS_AVAILABLE, 'No cloud regions available', undefined, [
+                'Contact support if you need access to cloud regions',
+            ]), logger, errorFormat ?? 'text');
+        }
+        return undefined;
+    }
+    // Check if region was provided via flag
+    let region = options.region;
+    // Validate --region flag if provided
+    if (region) {
+        const found = regions.find((r) => r.region === region);
+        if (!found) {
+            const errorFormat = options.errorFormat;
+            exitWithError(createError(ErrorCode.REGION_NOT_FOUND, `Invalid region '${region}'`, { region, availableRegions: regions.map((r) => r.region) }, [`Use one of: ${regions.map((r) => r.region).join(', ')}`]), logger, errorFormat ?? 'text');
+        }
+        return region;
+    }
+    // Auto-select if only one region available
+    if (regions.length === 1) {
+        region = regions[0].region;
+        if (!process.stdin.isTTY) {
+            logger.trace('auto-selected region (non-TTY): %s', region);
+        }
+        return region;
+    }
+    // No flag provided - handle TTY vs non-TTY
+    if (required && !process.stdin.isTTY) {
+        const errorFormat = options.errorFormat;
+        exitWithError(createError(ErrorCode.REGION_REQUIRED, '--region flag is required in non-interactive mode', { availableRegions: regions.map((r) => r.region) }, [`Use --region with one of: ${regions.map((r) => r.region).join(', ')}`]), logger, errorFormat ?? 'text');
+    }
+    if (process.stdin.isTTY) {
+        // Interactive mode - prompt user
+        region = await getRegion(regions);
+        return region;
+    }
+    // Non-interactive, optional region - return undefined
+    return undefined;
+}
+async function registerSubcommand(parent, subcommand, baseCtx, hidden) {
+    const cmd = parent.command(subcommand.name, { hidden }).description(subcommand.description);
+    if (subcommand.aliases) {
+        cmd.aliases(subcommand.aliases);
+    }
+    // Add examples to help text
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const examples = subcommand.examples;
+    if (examples && examples.length > 0) {
+        cmd.addHelpText('after', '\nExamples:\n' + examples.map((ex) => `  ${ex}`).join('\n'));
+    }
+    // Check if this subcommand has its own subcommands (nested subcommands)
+    const subDef = subcommand;
+    if (subDef.subcommands && subDef.subcommands.length > 0) {
+        // Register nested subcommands recursively
+        for (const nestedSub of subDef.subcommands) {
+            await registerSubcommand(cmd, nestedSub, baseCtx);
+        }
+        return;
+    }
+    const { requiresProject, optionalProject, requiresOrg, optionalOrg, requiresRegion, optionalRegion, } = normalizeReqs(subcommand);
+    if (requiresProject || optionalProject) {
+        cmd.option('--dir <path>', 'project directory (default: current directory)');
+    }
+    if (requiresOrg || optionalOrg) {
+        cmd.option('--org-id <id>', 'organization ID');
+    }
+    if (requiresRegion || optionalRegion) {
+        cmd.option('--region <region>', 'cloud region');
+    }
+    if (subcommand.schema?.args) {
+        const parsed = parseArgsSchema(subcommand.schema.args);
+        for (const argMeta of parsed.metadata) {
+            let argSyntax;
+            if (argMeta.variadic) {
+                argSyntax = argMeta.optional ? `[${argMeta.name}...]` : `<${argMeta.name}...>`;
+            }
+            else {
+                argSyntax = argMeta.optional ? `[${argMeta.name}]` : `<${argMeta.name}>`;
+            }
+            cmd.argument(argSyntax);
+        }
+    }
+    if (subcommand.schema?.options) {
+        const parsed = parseOptionsSchema(subcommand.schema.options);
+        for (const opt of parsed) {
+            const flag = opt.name.replace(/([A-Z])/g, '-$1').toLowerCase();
+            const desc = opt.description || '';
+            // Add short flag alias for verbose
+            const flagSpec = flag === 'verbose' ? `-v, --${flag}` : `--${flag}`;
+            if (opt.type === 'boolean') {
+                if (opt.hasDefault) {
+                    const defaultValue = typeof opt.defaultValue === 'function' ? opt.defaultValue() : opt.defaultValue;
+                    cmd.option(`--no-${flag}`, desc);
+                    cmd.option(flagSpec, desc, defaultValue);
+                }
+                else {
+                    cmd.option(flagSpec, desc);
+                }
+            }
+            else if (opt.type === 'number') {
+                cmd.option(`${flagSpec} <${opt.name}>`, desc, parseFloat);
+            }
+            else {
+                cmd.option(`${flagSpec} <${opt.name}>`, desc);
+            }
+        }
+    }
+    cmd.action(async (...rawArgs) => {
+        const cmdObj = rawArgs[rawArgs.length - 1];
+        const options = cmdObj.opts();
+        const args = rawArgs.slice(0, -1);
+        if (subcommand.banner) {
+            showBanner();
+        }
+        const normalized = normalizeReqs(subcommand);
+        let project;
+        let projectDir;
+        const dirNeeded = normalized.requiresProject || normalized.optionalProject;
+        if (dirNeeded) {
+            const dir = options.dir ?? process.cwd();
+            projectDir = dir;
+            try {
+                project = await loadProjectConfig(dir, baseCtx.config);
+            }
+            catch (error) {
+                if (normalized.requiresProject) {
+                    if (error &&
+                        typeof error === 'object' &&
+                        'name' in error &&
+                        error.name === 'ProjectConfigNotFoundExpection') {
+                        exitWithError(createError(ErrorCode.PROJECT_NOT_FOUND, 'Invalid project folder', undefined, [
+                            'Use --dir to specify a different directory',
+                            'Change to a directory containing agentuity.json',
+                            `Run "${getCommand('project create')}" to create a new project`,
+                        ]), baseCtx.logger, baseCtx.options.errorFormat);
+                    }
+                    throw error;
+                }
+                // For optional projects, silently continue without project config
+            }
+        }
+        if (normalized.requiresAuth) {
+            // Create apiClient before requireAuth since login command needs it
+            if (normalized.requiresAPIClient) {
+                baseCtx.apiClient = createAPIClient(baseCtx, baseCtx.config ?? null);
+            }
+            const auth = await requireAuth(baseCtx);
+            if (subcommand.schema) {
+                try {
+                    const input = buildValidationInput(subcommand.schema, args, options);
+                    const ctx = {
+                        ...baseCtx,
+                        config: {
+                            ...(baseCtx.config ?? {}),
+                            auth: {
+                                api_key: auth.apiKey,
+                                user_id: auth.userId,
+                                expires: auth.expires.getTime(),
+                            },
+                        },
+                        auth,
+                    };
+                    if (project || projectDir) {
+                        if (project) {
+                            ctx.project = project;
+                        }
+                        ctx.projectDir = projectDir;
+                    }
+                    if (subcommand.schema.args) {
+                        ctx.args = subcommand.schema.args.parse(input.args);
+                    }
+                    if (subcommand.schema.options) {
+                        ctx.opts = subcommand.schema.options.parse(input.options);
+                    }
+                    if (normalized.requiresAPIClient) {
+                        // Recreate apiClient with auth credentials
+                        ctx.apiClient = createAPIClient(baseCtx, ctx.config);
+                    }
+                    if (normalized.requiresOrg) {
+                        ctx.orgId = await requireOrg(ctx);
+                    }
+                    if (normalized.optionalOrg && ctx.auth) {
+                        ctx.orgId = await requireOrg(ctx);
+                    }
+                    if ((normalized.requiresRegion || normalized.optionalRegion) && ctx.apiClient) {
+                        const apiClient = ctx.apiClient;
+                        const region = await tui.spinner({
+                            message: 'Fetching cloud regions',
+                            clearOnSuccess: true,
+                            callback: async () => {
+                                return resolveRegion({
+                                    options: options,
+                                    apiClient,
+                                    logger: baseCtx.logger,
+                                    required: !!normalized.requiresRegion,
+                                });
+                            },
+                        });
+                        if (region) {
+                            ctx.region = region;
+                        }
+                    }
+                    await executeOrValidate(ctx, `${parent.name()} ${subcommand.name}`, subcommand.handler);
+                }
+                catch (error) {
+                    if (error && typeof error === 'object' && 'issues' in error) {
+                        handleValidationError(error, `${parent.name()} ${subcommand.name}`, baseCtx);
+                    }
+                    handleProjectConfigError(error, normalized.requiresProject, baseCtx.logger, baseCtx.options.errorFormat);
+                }
+            }
+            else {
+                const ctx = {
+                    ...baseCtx,
+                    config: baseCtx.config
+                        ? {
+                            ...baseCtx.config,
+                            name: baseCtx.config.name ?? defaultProfileName,
+                            auth: {
+                                api_key: auth.apiKey,
+                                user_id: auth.userId,
+                                expires: auth.expires.getTime(),
+                            },
+                        }
+                        : null,
+                    auth,
+                };
+                if (project || projectDir) {
+                    if (project) {
+                        ctx.project = project;
+                    }
+                    ctx.projectDir = projectDir;
+                }
+                if (normalized.requiresAPIClient) {
+                    // Recreate apiClient with auth credentials
+                    ctx.apiClient = createAPIClient(baseCtx, ctx.config);
+                }
+                if (normalized.requiresOrg) {
+                    ctx.orgId = await requireOrg(ctx);
+                }
+                if (normalized.optionalOrg && ctx.auth) {
+                    ctx.orgId = await requireOrg(ctx);
+                }
+                if ((normalized.requiresRegion || normalized.optionalRegion) && ctx.apiClient) {
+                    const apiClient = ctx.apiClient;
+                    const region = await tui.spinner('Fetching cloud regions', async () => {
+                        return resolveRegion({
+                            options: options,
+                            apiClient,
+                            logger: baseCtx.logger,
+                            required: !!normalized.requiresRegion,
+                        });
+                    });
+                    if (region) {
+                        ctx.region = region;
+                    }
+                }
+                if (subcommand.handler) {
+                    await subcommand.handler(ctx);
+                }
+            }
+        }
+        else if (normalized.optionalAuth) {
+            const continueText = typeof normalized.optionalAuth === 'string' ? normalized.optionalAuth : undefined;
+            // Create apiClient before optionalAuth since login command needs it
+            if (normalized.requiresAPIClient) {
+                baseCtx.apiClient = createAPIClient(baseCtx, baseCtx.config ?? null);
+            }
+            const auth = await optionalAuth(baseCtx, continueText);
+            if (subcommand.schema) {
+                try {
+                    const input = buildValidationInput(subcommand.schema, args, options);
+                    const ctx = {
+                        ...baseCtx,
+                        config: auth
+                            ? {
+                                ...(baseCtx.config ?? {}),
+                                auth: {
+                                    api_key: auth.apiKey,
+                                    user_id: auth.userId,
+                                    expires: auth.expires.getTime(),
+                                },
+                            }
+                            : baseCtx.config,
+                        auth,
+                    };
+                    if (project || projectDir) {
+                        if (project) {
+                            ctx.project = project;
+                        }
+                        ctx.projectDir = projectDir;
+                    }
+                    if (subcommand.schema.args) {
+                        ctx.args = subcommand.schema.args.parse(input.args);
+                    }
+                    if (subcommand.schema.options) {
+                        ctx.opts = subcommand.schema.options.parse(input.options);
+                    }
+                    if (normalized.requiresAPIClient) {
+                        // Recreate apiClient with auth credentials
+                        ctx.apiClient = createAPIClient(baseCtx, ctx.config);
+                    }
+                    baseCtx.logger.trace('optionalAuth path: org=%s, region=%s, hasApiClient=%s, hasAuth=%s', normalized.optionalOrg, normalized.optionalRegion, !!ctx.apiClient, !!auth);
+                    if (normalized.requiresOrg && ctx.apiClient) {
+                        ctx.orgId = await requireOrg(ctx);
+                    }
+                    if (normalized.optionalOrg && ctx.apiClient && auth) {
+                        ctx.orgId = await selectOptionalOrg(ctx);
+                        baseCtx.logger.trace('selected orgId: %s', ctx.orgId);
+                    }
+                    if ((normalized.requiresRegion || normalized.optionalRegion) &&
+                        ctx.apiClient &&
+                        auth) {
+                        const apiClient = ctx.apiClient;
+                        const region = await resolveRegion({
+                            options: options,
+                            apiClient,
+                            logger: baseCtx.logger,
+                            required: !!normalized.requiresRegion,
+                        });
+                        if (region) {
+                            ctx.region = region;
+                        }
+                    }
+                    await executeOrValidate(ctx, `${parent.name()} ${subcommand.name}`, subcommand.handler);
+                }
+                catch (error) {
+                    if (error && typeof error === 'object' && 'issues' in error) {
+                        handleValidationError(error, `${parent.name()} ${subcommand.name}`, baseCtx);
+                    }
+                    handleProjectConfigError(error, normalized.requiresProject, baseCtx.logger, baseCtx.options.errorFormat);
+                }
+            }
+            else {
+                const ctx = {
+                    ...baseCtx,
+                    config: auth
+                        ? {
+                            ...(baseCtx.config ?? {}),
+                            auth: {
+                                api_key: auth.apiKey,
+                                user_id: auth.userId,
+                                expires: auth.expires.getTime(),
+                            },
+                        }
+                        : baseCtx.config,
+                    auth,
+                };
+                if (project || projectDir) {
+                    if (project) {
+                        ctx.project = project;
+                    }
+                    ctx.projectDir = projectDir;
+                }
+                if (normalized.requiresAPIClient) {
+                    // Recreate apiClient with auth credentials if auth was provided
+                    ctx.apiClient = createAPIClient(baseCtx, ctx.config);
+                }
+                if (normalized.requiresOrg && ctx.apiClient) {
+                    ctx.orgId = await requireOrg(ctx);
+                }
+                if (normalized.optionalOrg && ctx.apiClient) {
+                    ctx.orgId = await selectOptionalOrg(ctx);
+                }
+                if ((normalized.requiresRegion || normalized.optionalRegion) && ctx.apiClient) {
+                    const apiClient = ctx.apiClient;
+                    const region = await resolveRegion({
+                        options: options,
+                        apiClient,
+                        logger: baseCtx.logger,
+                        required: !!normalized.requiresRegion,
+                    });
+                    if (region) {
+                        ctx.region = region;
+                    }
+                }
+                if (subcommand.handler) {
+                    await subcommand.handler(ctx);
+                }
+            }
+        }
+        else {
+            if (subcommand.schema) {
+                try {
+                    const input = buildValidationInput(subcommand.schema, args, options);
+                    const ctx = {
+                        ...baseCtx,
+                    };
+                    if (project || projectDir) {
+                        if (project) {
+                            ctx.project = project;
+                        }
+                        ctx.projectDir = projectDir;
+                    }
+                    if (subcommand.schema.args) {
+                        ctx.args = subcommand.schema.args.parse(input.args);
+                    }
+                    if (subcommand.schema.options) {
+                        ctx.opts = subcommand.schema.options.parse(input.options);
+                    }
+                    if (normalized.requiresAPIClient && !ctx.apiClient) {
+                        ctx.apiClient = createAPIClient(baseCtx, ctx.config);
+                    }
+                    if (normalized.requiresOrg && ctx.apiClient) {
+                        ctx.orgId = await requireOrg(ctx);
+                    }
+                    if (normalized.optionalOrg && ctx.apiClient && ctx.auth) {
+                        ctx.orgId = await requireOrg(ctx);
+                    }
+                    await executeOrValidate(ctx, `${parent.name()} ${subcommand.name}`, subcommand.handler);
+                }
+                catch (error) {
+                    if (error && typeof error === 'object' && 'issues' in error) {
+                        handleValidationError(error, `${parent.name()} ${subcommand.name}`, baseCtx);
+                    }
+                    handleProjectConfigError(error, normalized.requiresProject, baseCtx.logger, baseCtx.options.errorFormat);
+                }
+            }
+            else {
+                const ctx = {
+                    ...baseCtx,
+                };
+                if (project || projectDir) {
+                    if (project) {
+                        ctx.project = project;
+                    }
+                    ctx.projectDir = projectDir;
+                }
+                if (normalized.requiresAPIClient && !ctx.apiClient) {
+                    ctx.apiClient = createAPIClient(baseCtx, ctx.config);
+                }
+                if (normalized.requiresOrg && ctx.apiClient) {
+                    ctx.orgId = await requireOrg(ctx);
+                }
+                if (normalized.optionalOrg && ctx.apiClient && ctx.auth) {
+                    ctx.orgId = await requireOrg(ctx);
+                }
+                if ((normalized.requiresRegion || normalized.optionalRegion) && ctx.apiClient) {
+                    const apiClient = ctx.apiClient;
+                    const region = await resolveRegion({
+                        options: options,
+                        apiClient,
+                        logger: baseCtx.logger,
+                        required: !!normalized.requiresRegion,
+                    });
+                    if (region) {
+                        ctx.region = region;
+                    }
+                }
+                if (subcommand.handler) {
+                    await subcommand.handler(ctx);
+                }
+            }
+        }
+    });
+}
+export async function registerCommands(program, commands, baseCtx) {
+    for (const cmdDef of commands) {
+        if (cmdDef.subcommands) {
+            const cmd = program
+                .command(cmdDef.name, { hidden: cmdDef.hidden })
+                .description(cmdDef.description);
+            if (cmdDef.aliases) {
+                cmd.aliases(cmdDef.aliases);
+            }
+            if (cmdDef.handler) {
+                cmd.action(async () => {
+                    if (cmdDef.banner) {
+                        showBanner();
+                    }
+                    const normalized = normalizeReqs(cmdDef);
+                    if (normalized.requiresAuth) {
+                        // Create apiClient before requireAuth since login command needs it
+                        if (normalized.requiresAPIClient) {
+                            baseCtx.apiClient = createAPIClient(baseCtx, baseCtx.config ?? null);
+                        }
+                        const auth = await requireAuth(baseCtx);
+                        const ctx = {
+                            ...baseCtx,
+                            config: baseCtx.config
+                                ? {
+                                    ...baseCtx.config,
+                                    name: baseCtx.config.name ?? defaultProfileName,
+                                    auth: {
+                                        api_key: auth.apiKey,
+                                        user_id: auth.userId,
+                                        expires: auth.expires.getTime(),
+                                    },
+                                }
+                                : null,
+                            auth,
+                        };
+                        if (normalized.requiresAPIClient) {
+                            // Recreate apiClient with auth credentials
+                            ctx.apiClient = createAPIClient(baseCtx, ctx.config);
+                        }
+                        if ((normalized.requiresRegion || normalized.optionalRegion) && ctx.apiClient) {
+                            const apiClient = ctx.apiClient;
+                            const region = await resolveRegion({
+                                options: baseCtx.options,
+                                apiClient,
+                                logger: baseCtx.logger,
+                                required: !!normalized.requiresRegion,
+                            });
+                            if (region) {
+                                ctx.region = region;
+                            }
+                        }
+                        await cmdDef.handler(ctx);
+                    }
+                    else if (normalized.optionalAuth) {
+                        const continueText = typeof normalized.optionalAuth === 'string'
+                            ? normalized.optionalAuth
+                            : undefined;
+                        // Create apiClient before optionalAuth since login command needs it
+                        if (normalized.requiresAPIClient) {
+                            baseCtx.apiClient = createAPIClient(baseCtx, baseCtx.config ?? null);
+                        }
+                        const auth = await optionalAuth(baseCtx, continueText);
+                        const ctx = {
+                            ...baseCtx,
+                            config: auth
+                                ? baseCtx.config
+                                    ? {
+                                        ...baseCtx.config,
+                                        auth: {
+                                            api_key: auth.apiKey,
+                                            user_id: auth.userId,
+                                            expires: auth.expires.getTime(),
+                                        },
+                                    }
+                                    : {
+                                        auth: {
+                                            api_key: auth.apiKey,
+                                            user_id: auth.userId,
+                                            expires: auth.expires.getTime(),
+                                        },
+                                    }
+                                : baseCtx.config,
+                            auth,
+                        };
+                        if (normalized.requiresAPIClient) {
+                            // Recreate apiClient with auth credentials if auth was provided
+                            ctx.apiClient = createAPIClient(baseCtx, ctx.config);
+                        }
+                        if ((normalized.requiresRegion || normalized.optionalRegion) && ctx.apiClient) {
+                            const apiClient = ctx.apiClient;
+                            const region = await resolveRegion({
+                                options: baseCtx.options,
+                                apiClient,
+                                logger: baseCtx.logger,
+                                required: !!normalized.requiresRegion,
+                            });
+                            if (region) {
+                                ctx.region = region;
+                            }
+                        }
+                        await cmdDef.handler(ctx);
+                    }
+                    else {
+                        const ctx = {
+                            ...baseCtx,
+                        };
+                        if (normalized.requiresAPIClient && !ctx.apiClient) {
+                            ctx.apiClient = createAPIClient(baseCtx, baseCtx.config);
+                        }
+                        if ((normalized.requiresRegion || normalized.optionalRegion) && ctx.apiClient) {
+                            const apiClient = ctx.apiClient;
+                            const region = await resolveRegion({
+                                options: baseCtx.options,
+                                apiClient,
+                                logger: baseCtx.logger,
+                                required: !!normalized.requiresRegion,
+                            });
+                            if (region) {
+                                ctx.region = region;
+                            }
+                        }
+                        await cmdDef.handler(ctx);
+                    }
+                });
+            }
+            else {
+                cmd.action(() => cmd.help());
+            }
+            for (const sub of cmdDef.subcommands) {
+                await registerSubcommand(cmd, sub, baseCtx);
+            }
+        }
+        else {
+            await registerSubcommand(program, cmdDef, baseCtx, cmdDef.hidden);
+        }
+    }
+}
+//# sourceMappingURL=cli.js.map