@eide/foir-cli 0.1.34 → 0.1.35

package/dist/cli.js

@@ -9,37 +9,18 @@ import { createRequire } from 'module';
 import { Command } from 'commander';
 const require = createRequire(import.meta.url);
 const { version } = require('../package.json');
-// Auth commands
+// Auth commands (special — not GraphQL-driven)
 import { registerLoginCommand } from './commands/login.js';
 import { registerLogoutCommand } from './commands/logout.js';
 import { registerSelectProjectCommand } from './commands/select-project.js';
 import { registerWhoamiCommand } from './commands/whoami.js';
-// Resource commands
-import { registerRecordsCommands } from './commands/records.js';
-import { registerModelsCommands } from './commands/models.js';
-import { registerSearchCommands } from './commands/search.js';
-import { registerCustomersCommands } from './commands/customers.js';
-import { registerCustomerProfilesCommands } from './commands/customer-profiles.js';
-import { registerSegmentsCommands } from './commands/segments.js';
-import { registerExperimentsCommands } from './commands/experiments.js';
-import { registerSettingsCommands } from './commands/settings.js';
-import { registerApiKeysCommands } from './commands/api-keys.js';
-import { registerAuthProvidersCommands } from './commands/auth-providers.js';
-import { registerExtensionsCommands } from './commands/extensions.js';
-import { registerOperationsCommands } from './commands/operations.js';
-import { registerHooksCommands } from './commands/hooks.js';
-import { registerSchedulesCommands } from './commands/schedules.js';
+// Special commands (REST, codegen, scaffolding, multi-type search)
 import { registerMediaCommands } from './commands/media.js';
-import { registerContextCommands } from './commands/context.js';
-import { registerNotificationsCommands } from './commands/notifications.js';
-import { registerLocalesCommands } from './commands/locales.js';
-import { registerFilesCommands } from './commands/files.js';
-import { registerNotesCommands } from './commands/notes.js';
-import { registerVariantCatalogCommands } from './commands/variant-catalog.js';
-import { registerAuthConfigCommands } from './commands/auth-config.js';
-import { registerEmbeddingsCommands } from './commands/embeddings.js';
 import { registerPullCommand } from './commands/pull.js';
 import { registerCreateExtensionCommand } from './commands/create-extension.js';
+import { registerSearchCommands } from './commands/search.js';
+// Dynamic commands from command registry (replaces ~25 imperative command files)
+import { registerDynamicCommands } from './commands/register-commands.js';
 const program = new Command();
 program
     .name('foir')
@@ -58,36 +39,18 @@ function getGlobalOpts() {
         quiet: !!opts.quiet,
     };
 }
-// Register all command groups
+// Auth commands
 registerLoginCommand(program, getGlobalOpts);
 registerLogoutCommand(program, getGlobalOpts);
 registerSelectProjectCommand(program, getGlobalOpts);
 registerWhoamiCommand(program, getGlobalOpts);
-registerRecordsCommands(program, getGlobalOpts);
-registerModelsCommands(program, getGlobalOpts);
-registerSearchCommands(program, getGlobalOpts);
-registerCustomersCommands(program, getGlobalOpts);
-registerCustomerProfilesCommands(program, getGlobalOpts);
-registerSegmentsCommands(program, getGlobalOpts);
-registerExperimentsCommands(program, getGlobalOpts);
-registerSettingsCommands(program, getGlobalOpts);
-registerApiKeysCommands(program, getGlobalOpts);
-registerAuthProvidersCommands(program, getGlobalOpts);
-registerExtensionsCommands(program, getGlobalOpts);
-registerOperationsCommands(program, getGlobalOpts);
-registerHooksCommands(program, getGlobalOpts);
-registerSchedulesCommands(program, getGlobalOpts);
+// Special commands
 registerMediaCommands(program, getGlobalOpts);
-registerContextCommands(program, getGlobalOpts);
-registerNotificationsCommands(program, getGlobalOpts);
-registerLocalesCommands(program, getGlobalOpts);
-registerFilesCommands(program, getGlobalOpts);
-registerNotesCommands(program, getGlobalOpts);
-registerVariantCatalogCommands(program, getGlobalOpts);
-registerAuthConfigCommands(program, getGlobalOpts);
-registerEmbeddingsCommands(program, getGlobalOpts);
+registerSearchCommands(program, getGlobalOpts);
 // Codegen
 registerPullCommand(program, getGlobalOpts);
 // Scaffolding
 registerCreateExtensionCommand(program, getGlobalOpts);
+// All GraphQL-driven commands (models, records, locales, etc.)
+registerDynamicCommands(program, getGlobalOpts);
 program.parse();

package/dist/codegen/generators/model-types.js

@@ -147,7 +147,8 @@ function generateDataInterface(model, fields, interfaceName, allModels) {
                 }
             }
             // Only parameterize if all targets resolved — otherwise keep default generic
-            if (resolvedPreviewTypes.length === refTypes.length && resolvedPreviewTypes.length > 0) {
+            if (resolvedPreviewTypes.length === refTypes.length &&
+                resolvedPreviewTypes.length > 0) {
                 fieldType = `ReferenceValue<${resolvedPreviewTypes.join(' | ')}>`;
             }
         }

package/dist/commands/playground.d.ts

@@ -0,0 +1,4 @@
+import { type Command } from 'commander';
+import type { GlobalOptions } from '../lib/config.js';
+export declare function registerPlaygroundCommand(program: Command, getGlobalOpts: () => GlobalOptions): void;
+//# sourceMappingURL=playground.d.ts.map

package/dist/commands/playground.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../../src/commands/playground.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAMzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAgCtD,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,MAAM,aAAa,QA8QnC"}

package/dist/commands/playground.js

@@ -0,0 +1,270 @@
+import chalk from 'chalk';
+import * as readline from 'readline';
+import { homedir } from 'os';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { createClient } from '../lib/client.js';
+import { getProjectContext } from '../auth/credentials.js';
+import { ListModelsDocument } from '../graphql/generated.js';
+const HISTORY_FILE = join(homedir(), '.foir', 'repl-history');
+const MAX_HISTORY = 500;
+function loadHistory() {
+    try {
+        if (existsSync(HISTORY_FILE)) {
+            return readFileSync(HISTORY_FILE, 'utf-8')
+                .split('\n')
+                .filter(Boolean)
+                .slice(-MAX_HISTORY);
+        }
+    }
+    catch {
+        // ignore
+    }
+    return [];
+}
+function saveHistory(lines) {
+    try {
+        const dir = join(homedir(), '.foir');
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        writeFileSync(HISTORY_FILE, lines.slice(-MAX_HISTORY).join('\n') + '\n');
+    }
+    catch {
+        // ignore
+    }
+}
+export function registerPlaygroundCommand(program, getGlobalOpts) {
+    program
+        .command('playground')
+        .alias('repl')
+        .description('Interactive REPL with tab completion')
+        .action(async () => {
+        const opts = getGlobalOpts();
+        // Validate auth and create client
+        let client;
+        try {
+            client = await createClient(opts);
+        }
+        catch (err) {
+            throw new Error('Authentication required. Run `foir login` first.');
+        }
+        // Pre-fetch model keys for tab completion (don't block startup)
+        let modelKeys = [];
+        client
+            .request(ListModelsDocument, { limit: 200 })
+            .then((data) => {
+            modelKeys = data.models.items.map((m) => m.key);
+        })
+            .catch(() => {
+            /* ignore — completion just won't have model keys */
+        });
+        // Get project context for prompt
+        let projectName = 'no project';
+        try {
+            const ctx = await getProjectContext();
+            if (ctx?.name)
+                projectName = ctx.name;
+        }
+        catch {
+            // no project context
+        }
+        // Collect command names for completion
+        const commandNames = program.commands.map((c) => c.name());
+        const commandMap = new Map();
+        for (const cmd of program.commands) {
+            commandMap.set(cmd.name(), cmd);
+            for (const alias of cmd.aliases()) {
+                commandMap.set(alias, cmd);
+            }
+        }
+        // Build completer
+        const metaCommands = [
+            '.help',
+            '.clear',
+            '.exit',
+            '.commands',
+            '.context',
+            '.models',
+        ];
+        function completer(line) {
+            const trimmed = line.trim();
+            const parts = trimmed.split(/\s+/);
+            // Meta commands
+            if (parts.length === 1 && trimmed.startsWith('.')) {
+                const hits = metaCommands.filter((c) => c.startsWith(trimmed));
+                return [hits.length ? hits : metaCommands, trimmed];
+            }
+            // First word: command names
+            if (parts.length <= 1) {
+                const hits = commandNames.filter((c) => c.startsWith(trimmed));
+                return [hits.length ? hits : commandNames, trimmed];
+            }
+            // Second word: subcommands
+            const firstPart = parts[0] ?? '';
+            const cmd = commandMap.get(firstPart);
+            if (cmd && parts.length === 2) {
+                const subNames = cmd.commands.map((c) => c.name());
+                const partial = parts[1] ?? '';
+                const hits = subNames.filter((s) => s.startsWith(partial));
+                return [hits.length ? hits : subNames, partial];
+            }
+            // Level 3: model keys for records/search commands
+            const cmdName = cmd?.name();
+            if ((cmdName === 'records' || cmdName === 'search') &&
+                parts.length === 3 &&
+                modelKeys.length > 0) {
+                const partial = parts[2] ?? '';
+                const hits = modelKeys.filter((k) => k.startsWith(partial));
+                return [hits.length ? hits : modelKeys, partial];
+            }
+            // Flags
+            if (cmd) {
+                const lastPart = parts[parts.length - 1] ?? '';
+                if (lastPart.startsWith('-')) {
+                    const flags = cmd.options.map((o) => o.long).filter((f) => Boolean(f));
+                    const hits = flags.filter((f) => f.startsWith(lastPart));
+                    return [hits.length ? hits : [], lastPart];
+                }
+            }
+            return [[], trimmed];
+        }
+        // Load history
+        const history = loadHistory();
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            prompt: chalk.cyan(`foir (${projectName})> `),
+            completer,
+            history,
+            historySize: MAX_HISTORY,
+        });
+        console.log(chalk.bold('\nFoir Interactive Playground'));
+        console.log(chalk.dim('Type commands without the "foir" prefix. Use Tab for completion.'));
+        console.log(chalk.dim('Type .help for available meta-commands.\n'));
+        rl.prompt();
+        // Prevent Commander from calling process.exit()
+        program.exitOverride();
+        rl.on('line', async (line) => {
+            const input = line.trim();
+            if (!input) {
+                rl.prompt();
+                return;
+            }
+            // Meta commands
+            if (input === '.help') {
+                console.log(chalk.bold('\nMeta-commands:'));
+                console.log('  .help      Show this help');
+                console.log('  .clear     Clear terminal');
+                console.log('  .exit      Exit playground');
+                console.log('  .commands  List available commands');
+                console.log('  .context   Show current auth/project context');
+                console.log('  .models    Refresh and list model keys');
+                console.log(chalk.dim('\nRun any foir command without the "foir" prefix.'));
+                console.log(chalk.dim('Example: records list page\n'));
+                rl.prompt();
+                return;
+            }
+            if (input === '.clear') {
+                console.clear();
+                rl.prompt();
+                return;
+            }
+            if (input === '.exit' || input === 'exit' || input === 'quit') {
+                saveHistory(rl.history || []);
+                console.log(chalk.dim('Goodbye!'));
+                rl.close();
+                return;
+            }
+            if (input === '.commands') {
+                console.log(chalk.bold('\nAvailable commands:'));
+                for (const cmd of program.commands) {
+                    if (cmd.name() === 'playground')
+                        continue;
+                    const desc = cmd.description() || '';
+                    console.log(`  ${chalk.green(cmd.name().padEnd(24))} ${chalk.dim(desc)}`);
+                }
+                console.log('');
+                rl.prompt();
+                return;
+            }
+            if (input === '.context') {
+                try {
+                    const ctx = await getProjectContext();
+                    console.log(chalk.bold('\nCurrent context:'));
+                    if (ctx) {
+                        console.log(`  Project: ${chalk.green(ctx.name || 'unnamed')}`);
+                        console.log(`  ID:      ${chalk.dim(ctx.id || 'n/a')}`);
+                        console.log(`  Tenant:  ${chalk.dim(ctx.tenantId || 'n/a')}`);
+                    }
+                    else {
+                        console.log(chalk.yellow('  No project selected. Run: select-project'));
+                    }
+                }
+                catch {
+                    console.log(chalk.yellow('  No project context available.'));
+                }
+                console.log('');
+                rl.prompt();
+                return;
+            }
+            if (input === '.models') {
+                try {
+                    const data = await client.request(ListModelsDocument, {
+                        limit: 200,
+                    });
+                    modelKeys = data.models.items.map((m) => m.key);
+                    console.log(chalk.bold('\nModel keys:'));
+                    for (const key of modelKeys) {
+                        console.log(`  ${chalk.green(key)}`);
+                    }
+                    if (modelKeys.length === 0) {
+                        console.log(chalk.yellow('  No models found.'));
+                    }
+                }
+                catch {
+                    console.log(chalk.yellow('  Failed to fetch models.'));
+                }
+                console.log('');
+                rl.prompt();
+                return;
+            }
+            // Regular command - parse and execute via Commander
+            const args = input.match(/(?:[^\s"']+|"[^"]*"|'[^']*')/g) || [];
+            // Strip quotes from arguments
+            const cleanArgs = args.map((a) => a.replace(/^["']|["']$/g, ''));
+            try {
+                await program.parseAsync(['node', 'foir', ...cleanArgs], {
+                    from: 'user',
+                });
+            }
+            catch (err) {
+                // CommanderError is thrown by exitOverride instead of process.exit
+                if (err.code === 'commander.helpDisplayed' ||
+                    err.code === 'commander.version') {
+                    // Help/version output already printed
+                }
+                else if (err.code === 'commander.unknownCommand') {
+                    console.error(chalk.red(`Unknown command: ${cleanArgs[0]}`));
+                    console.log(chalk.dim('Type .commands to see available commands.'));
+                }
+                else if (err.exitCode !== undefined) {
+                    // Commander error with exit code - already printed message
+                }
+                else {
+                    // Application error
+                    console.error(chalk.red(err.message || String(err)));
+                }
+            }
+            console.log(''); // spacing
+            rl.prompt();
+        });
+        rl.on('close', () => {
+            saveHistory(rl.history || []);
+        });
+        // Handle SIGINT gracefully
+        rl.on('SIGINT', () => {
+            console.log(chalk.dim('\n(Use .exit or Ctrl+D to quit)'));
+            rl.prompt();
+        });
+    });
+}

package/dist/commands/register-commands.d.ts

@@ -0,0 +1,7 @@
+import type { Command } from 'commander';
+import type { GlobalOptions } from '../lib/config.js';
+/**
+ * Register all declarative commands from the command registry.
+ */
+export declare function registerDynamicCommands(program: Command, globalOpts: () => GlobalOptions): void;
+//# sourceMappingURL=register-commands.d.ts.map

package/dist/commands/register-commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-commands.d.ts","sourceRoot":"","sources":["../../src/commands/register-commands.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAOzC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AA0GtD;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,aAAa,GAC9B,IAAI,CA8LN"}

package/dist/commands/register-commands.js

@@ -0,0 +1,259 @@
+import { readFileSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { COMMANDS, createSchemaEngine, } from '@eide/command-registry';
+import { withErrorHandler } from '../lib/errors.js';
+import { createClient } from '../lib/client.js';
+import { formatOutput, formatList, timeAgo, success, } from '../lib/output.js';
+import { parseInputData, confirmAction, isUUID } from '../lib/input.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+function loadSchemaSDL() {
+    // Try monorepo path first (development)
+    const monorepoPath = resolve(__dirname, '../../../../graphql-core/schema.graphql');
+    try {
+        return readFileSync(monorepoPath, 'utf-8');
+    }
+    catch {
+        // Fall back to relative path from dist (might differ)
+        const altPath = resolve(__dirname, '../../../graphql-core/schema.graphql');
+        try {
+            return readFileSync(altPath, 'utf-8');
+        }
+        catch {
+            throw new Error('Could not find schema.graphql. Ensure you are running from within the EIDE monorepo.');
+        }
+    }
+}
+/**
+ * Extract the useful data from a GraphQL result, unwrapping list wrappers.
+ */
+function extractResult(result, operationName) {
+    const raw = result[operationName];
+    if (!raw || typeof raw !== 'object')
+        return { data: raw };
+    const obj = raw;
+    // Check for list wrappers: { items: [...], total } or { entityName: [...], total }
+    if ('total' in obj) {
+        for (const [key, val] of Object.entries(obj)) {
+            if (key !== 'total' && key !== '__typename' && Array.isArray(val)) {
+                return { data: val, total: obj.total };
+            }
+        }
+    }
+    return { data: raw };
+}
+/**
+ * Convert registry ColumnDef (with string format) to CLI ColumnDef (with format function).
+ */
+function toCliColumns(columns) {
+    if (!columns)
+        return undefined;
+    return columns.map((col) => {
+        const cliCol = {
+            key: col.key,
+            header: col.header,
+            width: col.width,
+        };
+        switch (col.format) {
+            case 'timeAgo':
+                cliCol.format = (v) => timeAgo(v);
+                break;
+            case 'boolean':
+                cliCol.format = (v) => (v ? 'yes' : '');
+                break;
+            case 'truncate':
+                cliCol.format = (v) => {
+                    const str = String(v ?? '');
+                    return str.length > 40 ? str.slice(0, 39) + '\u2026' : str;
+                };
+                break;
+            case 'join':
+                cliCol.format = (v) => Array.isArray(v) ? v.join(', ') : String(v ?? '');
+                break;
+            case 'bytes':
+                cliCol.format = (v) => {
+                    const num = Number(v);
+                    if (num < 1024)
+                        return `${num} B`;
+                    if (num < 1024 * 1024)
+                        return `${(num / 1024).toFixed(1)} KB`;
+                    return `${(num / (1024 * 1024)).toFixed(1)} MB`;
+                };
+                break;
+        }
+        return cliCol;
+    });
+}
+/**
+ * Register all declarative commands from the command registry.
+ */
+export function registerDynamicCommands(program, globalOpts) {
+    let engine;
+    try {
+        const sdl = loadSchemaSDL();
+        engine = createSchemaEngine(sdl);
+    }
+    catch (err) {
+        // If schema can't be loaded, skip dynamic command registration
+        // (special commands still work)
+        console.error(`Warning: Could not load schema for dynamic commands: ${err instanceof Error ? err.message : String(err)}`);
+        return;
+    }
+    // Group commands by group name
+    const groups = new Map();
+    for (const cmd of COMMANDS) {
+        if (!groups.has(cmd.group))
+            groups.set(cmd.group, []);
+        groups.get(cmd.group).push(cmd);
+    }
+    for (const [groupName, entries] of groups) {
+        const group = program.command(groupName).description(`Manage ${groupName}`);
+        for (const entry of entries) {
+            let cmd = group.command(entry.name).description(entry.description);
+            // Add positional args
+            for (const pos of entry.positionalArgs ?? []) {
+                cmd = cmd.argument(`<${pos.name}>`, pos.description ?? pos.name);
+            }
+            // Add flags from schema args (excluding positional args and input args)
+            const schemaArgs = engine.getOperationArgs(entry.operation, entry.operationType);
+            for (const arg of schemaArgs) {
+                // Skip if already a positional arg
+                if (entry.positionalArgs?.some((p) => p.graphqlArg === arg.name))
+                    continue;
+                // Skip if it's the input arg
+                if (entry.acceptsInput && arg.name === (entry.inputArgName ?? 'input'))
+                    continue;
+                const reqStr = arg.required ? ' (required)' : '';
+                cmd = cmd.option(`--${arg.name} <value>`, `${arg.name}${reqStr}`);
+            }
+            // Add --data/--file for input commands
+            if (entry.acceptsInput) {
+                cmd = cmd.option('-d, --data <json>', 'Data as JSON');
+                cmd = cmd.option('-f, --file <path>', 'Read data from file');
+            }
+            // Add --confirm for destructive commands
+            if (entry.requiresConfirmation) {
+                cmd = cmd.option('--confirm', 'Skip confirmation prompt');
+            }
+            // Action handler
+            cmd.action(withErrorHandler(globalOpts, async (...actionArgs) => {
+                const opts = globalOpts();
+                const client = await createClient(opts);
+                // Build variables from positional args + flags
+                const variables = {};
+                // Map positional args
+                const positionals = entry.positionalArgs ?? [];
+                for (let i = 0; i < positionals.length; i++) {
+                    const posDef = positionals[i];
+                    const value = actionArgs[i];
+                    if (value) {
+                        variables[posDef.graphqlArg] = value;
+                    }
+                }
+                // The flags/options object is the last argument from Commander
+                const flags = (actionArgs[positionals.length] ?? {});
+                // Map named flags to variables (coerce types)
+                const rawFlags = {};
+                for (const [key, val] of Object.entries(flags)) {
+                    if (key === 'data' || key === 'file' || key === 'confirm')
+                        continue;
+                    rawFlags[key] = String(val);
+                }
+                const coerced = engine.coerceArgs(entry.operation, entry.operationType, rawFlags);
+                Object.assign(variables, coerced);
+                // Handle input data (--data, --file, stdin)
+                if (entry.acceptsInput && (flags.data || flags.file)) {
+                    const inputData = await parseInputData({
+                        data: flags.data,
+                        file: flags.file,
+                    });
+                    const argName = entry.inputArgName ?? 'input';
+                    variables[argName] = inputData;
+                }
+                // Handle alternate get (by key/code instead of UUID)
+                if (entry.alternateGet &&
+                    positionals.length > 0 &&
+                    variables[positionals[0].graphqlArg]) {
+                    const firstArgValue = String(variables[positionals[0].graphqlArg]);
+                    if (!isUUID(firstArgValue)) {
+                        // Use alternate operation
+                        const altEntry = {
+                            ...entry,
+                            operation: entry.alternateGet.operation,
+                            positionalArgs: [
+                                {
+                                    name: positionals[0].name,
+                                    graphqlArg: entry.alternateGet.argName,
+                                },
+                            ],
+                        };
+                        // Remap the variable
+                        delete variables[positionals[0].graphqlArg];
+                        variables[entry.alternateGet.argName] = firstArgValue;
+                        const queryStr = engine.buildQuery(altEntry, variables);
+                        const result = (await client.request(queryStr, variables));
+                        const { data } = extractResult(result, altEntry.operation);
+                        formatOutput(data, opts);
+                        return;
+                    }
+                }
+                // Confirmation prompt for destructive actions
+                if (entry.requiresConfirmation) {
+                    const confirmed = await confirmAction(`${entry.description}?`, {
+                        confirm: !!flags.confirm,
+                    });
+                    if (!confirmed) {
+                        console.log('Aborted.');
+                        return;
+                    }
+                }
+                // Build and execute query
+                const queryStr = engine.buildQuery(entry, variables);
+                const result = (await client.request(queryStr, variables));
+                const { data, total } = extractResult(result, entry.operation);
+                // Format output
+                if (entry.scalarResult) {
+                    if (!(opts.json || opts.jsonl || opts.quiet)) {
+                        if (entry.successMessage) {
+                            success(entry.successMessage);
+                        }
+                    }
+                    else {
+                        formatOutput(data, opts);
+                    }
+                }
+                else if (Array.isArray(data)) {
+                    const cliColumns = toCliColumns(entry.columns);
+                    formatList(data, opts, {
+                        columns: cliColumns ?? autoColumns(data),
+                        total,
+                    });
+                }
+                else {
+                    formatOutput(data, opts);
+                    if (entry.successMessage &&
+                        !(opts.json || opts.jsonl || opts.quiet)) {
+                        success(entry.successMessage);
+                    }
+                }
+            }));
+        }
+    }
+}
+/**
+ * Auto-generate column definitions from the first item in an array.
+ */
+function autoColumns(items) {
+    if (items.length === 0)
+        return [];
+    const first = items[0];
+    return Object.keys(first)
+        .filter((k) => k !== '__typename')
+        .slice(0, 6)
+        .map((key) => ({
+        key,
+        header: key,
+        width: 20,
+    }));
+}

package/dist/commands/select-project.js

@@ -38,8 +38,8 @@ async function fetchSessionContext(apiUrl, accessToken) {
     return data.sessionContext;
 }
 async function fetchApiKeys(apiUrl, accessToken, projectId, tenantId) {
-    const data = await gqlRequest(apiUrl, accessToken, `query { listApiKeys(includeInactive: false, limit: 100) { apiKeys { id name isActive } } }`, undefined, { 'x-tenant-id': tenantId, 'x-project-id': projectId });
-    return data.listApiKeys?.apiKeys ?? [];
+    const data = await gqlRequest(apiUrl, accessToken, `query { listApiKeys(includeInactive: false, limit: 100) { items { id name isActive } } }`, undefined, { 'x-tenant-id': tenantId, 'x-project-id': projectId });
+    return data.listApiKeys?.items ?? [];
 }
 async function createApiKey(apiUrl, accessToken, projectId, tenantId) {
     const data = await gqlRequest(apiUrl, accessToken, `mutation($input: CreateApiKeyInput!) { createApiKey(input: $input) { apiKey { id name isActive } plainKey } }`, {