@quonfig/cli 0.0.1

package/dist/commands/whoami.js

@@ -0,0 +1,52 @@
+import { BaseCommand } from '../index.js';
+import { decodeJWT } from '../util/oauth-client.js';
+import { getActiveProfile, loadAuthConfig, loadTokens } from '../util/token-storage.js';
+export default class Whoami extends BaseCommand {
+    static description = 'Display information about the currently logged in user';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        const authConfig = await loadAuthConfig();
+        const tokens = await loadTokens();
+        if (!authConfig || !tokens?.accessToken) {
+            this.log('Not logged in. Use `qfg login` to authenticate.');
+            return {
+                loggedIn: false,
+            };
+        }
+        // Get email from stored user info or decode JWT
+        let userEmail = tokens.userEmail;
+        let orgId;
+        if (!userEmail) {
+            try {
+                const payload = decodeJWT(tokens.accessToken);
+                userEmail = payload.email;
+                orgId = payload.org_id;
+            }
+            catch {
+                // If we can't decode the token, continue without email
+            }
+        }
+        // Get the active profile
+        const activeProfile = getActiveProfile();
+        const profile = authConfig.profiles[activeProfile] || authConfig.profiles[authConfig.defaultProfile || 'default'];
+        if (!profile) {
+            this.log('Not logged in. Use `qfg login` to authenticate.');
+            return {
+                loggedIn: false,
+            };
+        }
+        // Display user information
+        this.log(`Logged in as: ${userEmail || 'Unknown'}`);
+        this.log(`Active profile: ${activeProfile}`);
+        this.log(`Active workspace: ${profile.workspaceName || profile.workspace}`);
+        return {
+            email: userEmail,
+            loggedIn: true,
+            organizationId: orgId || profile.workspace,
+            profile: activeProfile,
+            userId: tokens.userId,
+            workspace: profile.workspace,
+            workspaceName: profile.workspaceName,
+        };
+    }
+}

package/dist/commands/workspace.d.ts

@@ -0,0 +1,7 @@
+import type { JsonObj } from '../result.js';
+import { BaseCommand } from '../index.js';
+export default class Workspace extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    run(): Promise<JsonObj | void>;
+}

package/dist/commands/workspace.js

@@ -0,0 +1,38 @@
+import { BaseCommand } from '../index.js';
+import { getActiveProfile, loadAuthConfig } from '../util/token-storage.js';
+export default class Workspace extends BaseCommand {
+    static description = 'Display current workspace. To switch workspaces, run `qfg login --profile <name>`.';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        const authConfig = await loadAuthConfig();
+        if (!authConfig || Object.keys(authConfig.profiles).length === 0) {
+            return this.err('Not logged in. Please run `qfg login` first.');
+        }
+        // Get the active profile
+        const activeProfile = getActiveProfile();
+        const profile = authConfig.profiles[activeProfile] || authConfig.profiles[authConfig.defaultProfile || 'default'];
+        if (!profile) {
+            return this.err('No active profile found. Please run `qfg login` first.');
+        }
+        this.log(`Active profile: ${activeProfile}`);
+        this.log(`Workspace: ${profile.workspaceName || profile.workspace}`);
+        // Show all profiles if more than one
+        const profileNames = Object.keys(authConfig.profiles);
+        if (profileNames.length > 1) {
+            this.log('\nAll profiles:');
+            for (const name of profileNames) {
+                const p = authConfig.profiles[name];
+                const marker = name === activeProfile ? ' (active)' : '';
+                this.log(`  ${name}: ${p.workspaceName || p.workspace}${marker}`);
+            }
+            this.log('\nTo switch, use: qfg login --profile <name>');
+            this.log('To change default: qfg profile');
+        }
+        return {
+            activeProfile,
+            profiles: Object.fromEntries(profileNames.map((name) => [name, authConfig.profiles[name]])),
+            workspace: profile.workspace,
+            workspaceName: profile.workspaceName,
+        };
+    }
+}

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_ENVIRONMENT_NAME = "Default";
+export declare const INHERIT = "[inherit]";

package/dist/constants.js

@@ -0,0 +1,2 @@
+export const DEFAULT_ENVIRONMENT_NAME = 'Default';
+export const INHERIT = '[inherit]';

package/dist/help.d.ts

@@ -0,0 +1,4 @@
+import { Help } from '@oclif/core';
+export default class MyHelpClass extends Help {
+    showRootHelp(): Promise<void>;
+}

package/dist/help.js

@@ -0,0 +1,10 @@
+import { Help } from '@oclif/core';
+import { interactivePrompt } from './interactive-prompt.js';
+export default class MyHelpClass extends Help {
+    async showRootHelp() {
+        if (process.argv.slice(2).includes('--help')) {
+            return super.showRootHelp();
+        }
+        await interactivePrompt(this.config);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+export { run } from '@oclif/core';
+import { Command } from '@oclif/core';
+import { Client } from '@quonfig/node';
+import type { ProjectEnvId } from '@quonfig/node';
+import { JsonObj, Result } from './result.js';
+export declare abstract class BaseCommand extends Command {
+    static baseFlags: {
+        interactive: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        'no-color': import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    static enableJsonFlag: boolean;
+    err: (error: Error | object | string, json?: JsonObj) => never;
+    isVerbose: boolean;
+    ok: (message: object | string, json?: JsonObj) => JsonObj;
+    resultMessage: (result: Result<unknown>) => string | JsonObj | null;
+    verboseLog: (category: string | unknown, message?: unknown) => void;
+    protected catch(err: {
+        exitCode?: number;
+        code?: string;
+    } & Error): Promise<void>;
+    init(): Promise<void>;
+}
+export declare abstract class APICommand extends BaseCommand {
+    static baseFlags: {
+        profile: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        interactive: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        'no-color': import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    currentEnvironment: ProjectEnvId;
+    rawApiClient: Client;
+    workspaceId?: string;
+    get apiClient(): {
+        get: (path: string) => Promise<import("./result.js").RequestResult>;
+        post: (path: string, payload: unknown) => Promise<import("./result.js").RequestResult>;
+        put: (path: string, payload: unknown) => Promise<import("./result.js").RequestResult>;
+    };
+    init(): Promise<void>;
+}

package/dist/index.js

@@ -0,0 +1,112 @@
+export { run } from '@oclif/core';
+import { Command, Flags } from '@oclif/core';
+import rawGetClient, { unwrapRequest } from './util/get-client.js';
+const globalFlags = {
+    interactive: Flags.boolean({
+        allowNo: true,
+        default: true,
+        description: 'Force interactive mode',
+        helpGroup: 'GLOBAL',
+    }),
+    'no-color': Flags.boolean({
+        default: false,
+        description: 'Do not colorize output',
+        env: 'NO_COLOR',
+        helpGroup: 'GLOBAL',
+    }),
+    verbose: Flags.boolean({
+        default: false,
+        description: 'Verbose output',
+        helpGroup: 'GLOBAL',
+    }),
+};
+export class BaseCommand extends Command {
+    static baseFlags = {
+        ...globalFlags,
+    };
+    static enableJsonFlag = true;
+    err = (error, json) => {
+        if (this.jsonEnabled()) {
+            throw json ?? error;
+        }
+        if (typeof error === 'string') {
+            return this.error(error, { code: 'ERR', exit: 1 });
+        }
+        this.error(this.toErrorJson(error), { code: 'ERR', exit: 1 });
+    };
+    isVerbose;
+    ok = (message, json) => {
+        if (typeof message === 'string') {
+            this.log(message);
+        }
+        else {
+            this.log(this.toSuccessJson(message));
+        }
+        return json ?? { message };
+    };
+    resultMessage = (result) => {
+        if (result.error) {
+            return this.err(result.message, result.json);
+        }
+        if (result.message) {
+            this.log(result.message);
+            return result.json ?? result.message;
+        }
+        return null;
+    };
+    verboseLog = (category, message) => {
+        if (!this.isVerbose)
+            return;
+        if (message) {
+            this.logToStderr(`[${category}] ${typeof message === 'string' ? message : JSON.stringify(message)}`);
+        }
+        else {
+            this.logToStderr(typeof category === 'string' ? category : JSON.stringify(category));
+        }
+    };
+    async catch(err) {
+        // Override oclif's default error handling to suppress stack traces in production
+        // but preserve error messages for tests
+        // In test environment, just re-throw the error
+        if (process.env.NODE_ENV === 'test') {
+            throw err;
+        }
+        // In production, log the error message without stack trace
+        this.log(err.message);
+        this.exit(err.exitCode || 1);
+    }
+    async init() {
+        await super.init();
+        const { flags } = await this.parse();
+        this.isVerbose = flags.verbose;
+    }
+}
+export class APICommand extends BaseCommand {
+    static baseFlags = {
+        ...globalFlags,
+        profile: Flags.string({
+            char: 'p',
+            description: 'Profile to use (defaults to ENV var QUONFIG_PROFILE or "default")',
+            helpGroup: 'GLOBAL',
+            required: false,
+        }),
+    };
+    currentEnvironment;
+    rawApiClient;
+    workspaceId;
+    get apiClient() {
+        return {
+            get: async (path) => unwrapRequest(this, this.rawApiClient.get(path)),
+            post: async (path, payload) => unwrapRequest(this, this.rawApiClient.post(path, payload)),
+            put: async (path, payload) => unwrapRequest(this, this.rawApiClient.put(path, payload)),
+        };
+    }
+    async init() {
+        await super.init();
+        const { flags } = await this.parse();
+        this.rawApiClient = await rawGetClient(this, undefined, flags.profile);
+        // For JWT-based auth, we'll need to get environment info from the token
+        // For now, set a placeholder - this should be enhanced later
+        this.currentEnvironment = { id: 'unknown', projectId: 0 };
+    }
+}

package/dist/interactive-prompt.d.ts

@@ -0,0 +1,2 @@
+import { Config } from '@oclif/core/lib/interfaces/index.js';
+export declare const interactivePrompt: (config: Config) => Promise<void>;

package/dist/interactive-prompt.js

@@ -0,0 +1,162 @@
+import Create from './commands/create.js';
+import Download from './commands/download.js';
+import GenerateNewHexKey from './commands/generate-new-hex-key.js';
+import Get from './commands/get.js';
+import Info from './commands/info.js';
+import List from './commands/list.js';
+import Mcp from './commands/mcp.js';
+import Override from './commands/override.js';
+import Serve from './commands/serve.js';
+import SetDefault from './commands/set-default.js';
+import { APICommand } from './index.js';
+import getString from './ui/get-string.js';
+import autocomplete from './util/autocomplete.js';
+import { green } from './util/color.js';
+const convertToKebabCase = (text) => text
+    .replaceAll(/([A-Z])/g, ' $1')
+    .trim()
+    .replaceAll(' ', '-')
+    .toLowerCase();
+const commands = [
+    SetDefault,
+    GenerateNewHexKey,
+    Create,
+    Get,
+    Info,
+    Download,
+    Mcp,
+    Override,
+    List,
+    Serve,
+].map((command) => {
+    const id = convertToKebabCase(command.name);
+    return {
+        command,
+        description: command.description,
+        displayCommandName: id,
+        id,
+        implicitFlags: [],
+    };
+});
+commands.push({
+    command: SetDefault,
+    description: 'Set/update the default value for an environment to an ENV Var',
+    displayCommandName: 'set-default --env-var',
+    id: 'set-default',
+    implicitFlags: ['env-var'],
+}, {
+    command: SetDefault,
+    description: 'Set/update the default value for an environment with --secret',
+    displayCommandName: 'set-default --secret',
+    id: 'set-default',
+    implicitFlags: ['secret'],
+}, {
+    command: Create,
+    description: 'Create a new item in Quonfig with --secret',
+    displayCommandName: 'create --secret',
+    id: 'create',
+    implicitFlags: ['secret'],
+}, {
+    command: Create,
+    description: 'Create an ENV Var provided item in Quonfig with --env-var',
+    displayCommandName: 'create --env-var',
+    id: 'create',
+    implicitFlags: ['env-var'],
+});
+const descriptions = {};
+for (const command of commands) {
+    descriptions[command.displayCommandName] = command.description.split('\n')[0];
+}
+const isAPICommand = (command) => 
+// Check if command extends APICommand by checking prototype chain
+command.prototype instanceof APICommand;
+const promptForInput = async (arg, name, commandId, command) => {
+    let value;
+    const message = arg.description ?? name;
+    if (arg.options) {
+        value = await autocomplete({ message, source: arg.options });
+    }
+    else {
+        switch (arg.type) {
+            case 'option': {
+                // APICommand-based commands handle their own "name" arg prompting with autocomplete from metadata API
+                // Skip prompting here for those commands (except create which needs the name upfront)
+                if (name === 'name' && commandId !== 'create' && isAPICommand(command)) {
+                    // Skip prompting - let the OAuth command handle it interactively
+                    value = undefined;
+                }
+                else {
+                    value = await getString({ allowBlank: false, message });
+                }
+                break;
+            }
+            default: {
+                throw new Error(`Unknown arg type: ${arg.type}`);
+            }
+        }
+    }
+    if (!value && name !== 'name') {
+        throw new Error(`Missing required argument: ${name}`);
+    }
+    return value;
+};
+const getArgs = async (args, commandId, command) => {
+    const requiredArgs = Object.keys(args);
+    const values = await Promise.all(Object.entries(args)
+        .filter(([key]) => requiredArgs.includes(key))
+        .map(([key, arg]) => promptForInput(arg, key, commandId, command)));
+    // Filter out undefined values (OAuth commands handle their own name prompting)
+    return values.filter((v) => v !== undefined);
+};
+const getFlags = async (flags, commandId, implicitFlags, command) => {
+    if (!flags && implicitFlags.length === 0) {
+        return [];
+    }
+    const inputs = [];
+    const promiseInputs = [];
+    for (const [key, arg] of Object.entries(flags)) {
+        if (arg.required || implicitFlags.includes(key)) {
+            if (arg.type === 'boolean') {
+                inputs.push(`--${key}`);
+            }
+            else {
+                // eslint-disable-next-line no-await-in-loop
+                const value = await promptForInput(arg, key, commandId, command);
+                inputs.push(`--${key}=${value}`);
+            }
+        }
+    }
+    await Promise.all(promiseInputs);
+    return inputs;
+};
+export const interactivePrompt = async (config) => {
+    const longestCommandId = commands
+        .map((c) => c.displayCommandName.length)
+        .sort((a, b) => a - b)
+        .reverse()[0];
+    const namesAndDescriptions = commands
+        .map((command) => ({
+        description: `${command.displayCommandName}${' '.repeat(longestCommandId - command.displayCommandName.length + 4)} ${descriptions[command.displayCommandName]}`.replaceAll('the provided', 'a'),
+        id: command.displayCommandName,
+    }))
+        .sort((a, b) => a.description.localeCompare(b.description));
+    const selectedChoice = await autocomplete({
+        message: green('What would you like to do?'),
+        source: namesAndDescriptions.map((c) => c.description),
+    });
+    const selectedCommandId = namesAndDescriptions.find((c) => c.description === selectedChoice)?.id;
+    if (selectedCommandId) {
+        const chosenCommand = commands.find((c) => c.displayCommandName === selectedCommandId);
+        if (!chosenCommand) {
+            return;
+        }
+        const cliArgs = process.argv.slice(2);
+        const args = await getArgs(chosenCommand.command.args, chosenCommand.id, chosenCommand.command);
+        const flags = await getFlags(chosenCommand.command.flags, chosenCommand.id, chosenCommand.implicitFlags, chosenCommand.command);
+        const allArgs = [...cliArgs, ...args, ...flags];
+        if (process.env.VERBOSE) {
+            allArgs.push('--verbose');
+        }
+        await config.runCommand(chosenCommand.id, allArgs);
+    }
+};

package/dist/quonfig.d.ts

@@ -0,0 +1,15 @@
+import { Quonfig } from '@quonfig/node';
+import type { Value } from '@quonfig/node';
+import { CommandLike } from './ui/get-key.js';
+type Flags = {
+    ['sdk-key']?: string;
+};
+type FlagsOrDatafile = Flags | string;
+export declare const initQuonfig: (_ctx: CommandLike, flagsOrDatafile: FlagsOrDatafile) => Promise<Quonfig>;
+export declare const getQuonfig: () => Quonfig;
+export declare const overrideFor: ({ currentEnvironmentId, key, }: {
+    currentEnvironmentId: string;
+    key: string;
+}) => Value | undefined;
+export declare const defaultValueFor: (_envId: string, key: string) => Value | undefined;
+export {};

package/dist/quonfig.js

@@ -0,0 +1,75 @@
+import { Quonfig } from '@quonfig/node';
+let quonfig;
+const DEFAULT_CONTEXT_USER_ID_NAMESPACE = 'prefab-api-key';
+const DEFAULT_CONTEXT_USER_ID = 'user-id';
+export const initQuonfig = async (_ctx, flagsOrDatafile) => {
+    let sdkKey = 'NO_API_KEY';
+    let datafile;
+    if (typeof flagsOrDatafile === 'string') {
+        datafile = flagsOrDatafile;
+    }
+    else {
+        if (!flagsOrDatafile['sdk-key']) {
+            throw new Error(`SDK key is required`);
+        }
+        sdkKey = flagsOrDatafile['sdk-key'];
+    }
+    const apiUrl = process.env.QUONFIG_API_URL || 'https://api.quonfig.com';
+    quonfig = new Quonfig({
+        sdkKey,
+        collectEvaluationSummaries: false,
+        collectLoggerCounts: false,
+        contextUploadMode: 'none',
+        datafile,
+        enableSSE: false,
+        apiUrl,
+    });
+    await quonfig.init();
+    return quonfig;
+};
+export const getQuonfig = () => quonfig;
+/**
+ * Get the raw ConfigResponse for a key (new quonfig JSON format).
+ * The new format uses `default.rules` and `environment.rules` instead of `rows`.
+ */
+const getRawConfig = (key) => {
+    return quonfig.rawConfig?.(key);
+};
+/**
+ * Find rules in an environment that target a specific user via criteria.
+ */
+const getEnvironmentRules = (config) => {
+    return config.environment?.rules;
+};
+export const overrideFor = ({ currentEnvironmentId, key, }) => {
+    const config = getRawConfig(key);
+    if (!config)
+        return undefined;
+    // In the new format, environment-specific rules are in config.environment.rules
+    const rules = getEnvironmentRules(config);
+    if (!rules)
+        return undefined;
+    for (const rule of rules) {
+        for (const criterion of rule.criteria) {
+            if (criterion.propertyName === `${DEFAULT_CONTEXT_USER_ID_NAMESPACE}.${DEFAULT_CONTEXT_USER_ID}`) {
+                return rule.value;
+            }
+        }
+    }
+    return undefined;
+};
+export const defaultValueFor = (_envId, key) => {
+    const config = getRawConfig(key);
+    if (!config)
+        return undefined;
+    // In the new format, the default value is the last rule in environment rules, or default rules
+    const envRules = config.environment?.rules;
+    if (envRules && envRules.length > 0) {
+        return envRules[envRules.length - 1]?.value;
+    }
+    const defaultRules = config.default?.rules;
+    if (defaultRules && defaultRules.length > 0) {
+        return defaultRules[defaultRules.length - 1]?.value;
+    }
+    return undefined;
+};

package/dist/result.d.ts

@@ -0,0 +1,35 @@
+export type Result<T> = Failure | Noop | Success<T>;
+export type JsonObj = Record<string, unknown>;
+export type Noop = {
+    error: false;
+    json?: JsonObj;
+    message?: string;
+    ok: false;
+};
+export type Failure = {
+    error: true;
+    json?: JsonObj;
+    message: string;
+    ok: false;
+};
+export type Success<T> = {
+    error: false;
+    json?: JsonObj;
+    message?: string;
+    ok: true;
+    value: T;
+};
+export declare const noop: (message?: string) => Noop;
+export declare const failure: (message: string, json?: JsonObj) => Failure;
+export declare const success: <T>(value: T, message?: string, json?: JsonObj) => Success<T>;
+export type RequestSuccess = {
+    json: JsonObj;
+    ok: true;
+    status: number;
+};
+export type RequestFailure = {
+    error: JsonObj;
+    ok: false;
+    status: number;
+};
+export type RequestResult = RequestFailure | RequestSuccess;

package/dist/result.js

@@ -0,0 +1,9 @@
+export const noop = (message) => ({ error: false, message, ok: false });
+export const failure = (message, json) => ({ error: true, json, message, ok: false });
+export const success = (value, message, json) => ({
+    error: false,
+    json,
+    message,
+    ok: true,
+    value,
+});

package/dist/services/mcp.d.ts

@@ -0,0 +1,15 @@
+export declare const SupportedEditors: readonly ["claude-code", "codeium"];
+export type SupportedEditor = (typeof SupportedEditors)[number];
+type ConfigPaths = {
+    name: string;
+    global: {
+        mac: string;
+        windows: string;
+        linux?: string;
+    } | string;
+    local?: string;
+};
+export declare const ConfigPaths: Record<SupportedEditor, ConfigPaths>;
+export declare function resolveConfigPath(editor: SupportedEditor, local?: boolean): string | undefined;
+export declare function getServersConfig(editorConfig: Record<string, unknown>): Record<string, unknown>;
+export {};

package/dist/services/mcp.js

@@ -0,0 +1,59 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export const SupportedEditors = ['claude-code', 'codeium'];
+export const ConfigPaths = {
+    // cursor: {
+    //   name: 'Cursor',
+    //   global: '~/.cursor/mcp.json',
+    //   local: '.cursor/mcp.json',
+    // },
+    'claude-code': {
+        name: 'Claude Code',
+        global: '~/.claude.json',
+    },
+    codeium: {
+        name: 'Codeium (Codex)',
+        global: {
+            mac: '~/Library/Application Support/Codeium/mcp_config.json',
+            windows: '@/Codeium/mcp_config.json',
+            linux: '~/.config/codeium/mcp_config.json',
+        },
+    },
+};
+function resolvePath(path) {
+    if (path.startsWith('~/')) {
+        return join(homedir(), path.slice(2));
+    }
+    if (path.startsWith('@/')) {
+        // Windows AppData
+        const appData = process.env.APPDATA || join(homedir(), 'AppData', 'Roaming');
+        return join(appData, path.slice(2));
+    }
+    return path;
+}
+export function resolveConfigPath(editor, local = false) {
+    const editorConfig = ConfigPaths[editor];
+    const paths = local ? editorConfig.local : editorConfig.global;
+    if (!paths)
+        return undefined;
+    if (typeof paths === 'string') {
+        return resolvePath(paths);
+    }
+    // Platform-specific paths
+    switch (process.platform) {
+        case 'darwin':
+            return resolvePath(paths.mac);
+        case 'win32':
+            return resolvePath(paths.windows);
+        case 'linux':
+            return paths.linux ? resolvePath(paths.linux) : undefined;
+        default:
+            return undefined;
+    }
+}
+export function getServersConfig(editorConfig) {
+    if (!editorConfig.mcpServers) {
+        editorConfig.mcpServers = {};
+    }
+    return editorConfig.mcpServers;
+}

package/dist/ui/get-confirmation.d.ts

@@ -0,0 +1,10 @@
+export declare const confirmFlag: {
+    confirm: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+};
+declare const getConfirmation: ({ flags, message }: {
+    flags: {
+        confirm?: boolean;
+    };
+    message: string;
+}) => Promise<boolean>;
+export default getConfirmation;

package/dist/ui/get-confirmation.js

@@ -0,0 +1,4 @@
+import { Flags, ux } from '@oclif/core';
+export const confirmFlag = { confirm: Flags.boolean({ description: 'confirm without prompt' }) };
+const getConfirmation = async ({ flags, message }) => flags.confirm || ux.confirm(message);
+export default getConfirmation;