@agents-at-scale/ark 0.1.41 → 0.1.43

package/dist/commands/models/providers/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Provider configuration types and collectors.
+ *
+ * This module exports all provider-specific configurations and their collectors.
+ */
+export { BaseProviderConfig, BaseCollectorOptions, ProviderConfigCollector, } from './types.js';
+export { OpenAIConfig, OpenAICollectorOptions, OpenAIConfigCollector, } from './openai.js';
+export { AzureConfig, AzureCollectorOptions, AzureConfigCollector, } from './azure.js';
+export { BedrockConfig, BedrockCollectorOptions, BedrockConfigCollector, } from './bedrock.js';
+export { ProviderConfigCollectorFactory } from './factory.js';
+import { OpenAIConfig } from './openai.js';
+import { AzureConfig } from './azure.js';
+import { BedrockConfig } from './bedrock.js';
+/**
+ * Union type of all supported provider configurations.
+ */
+export type ProviderConfig = OpenAIConfig | AzureConfig | BedrockConfig;

package/dist/commands/models/providers/index.js

@@ -0,0 +1,9 @@
+/**
+ * Provider configuration types and collectors.
+ *
+ * This module exports all provider-specific configurations and their collectors.
+ */
+export { OpenAIConfigCollector, } from './openai.js';
+export { AzureConfigCollector, } from './azure.js';
+export { BedrockConfigCollector, } from './bedrock.js';
+export { ProviderConfigCollectorFactory } from './factory.js';

package/dist/commands/models/providers/openai.d.ts

@@ -0,0 +1,28 @@
+import { BaseProviderConfig, BaseCollectorOptions, ProviderConfigCollector } from './types.js';
+/**
+ * Configuration for OpenAI models.
+ */
+export interface OpenAIConfig extends BaseProviderConfig {
+    type: 'openai';
+    baseUrl: string;
+    apiKey: string;
+}
+/**
+ * Options specific to OpenAI collector.
+ */
+export interface OpenAICollectorOptions extends BaseCollectorOptions {
+    baseUrl?: string;
+    apiKey?: string;
+}
+/**
+ * Configuration collector for OpenAI models.
+ *
+ * Collects the necessary configuration to connect to an OpenAI-compatible API:
+ * - baseUrl: The API endpoint URL (e.g., https://api.openai.com/v1)
+ * - apiKey: The authentication key for the API
+ *
+ * Values can be provided via command-line options or will be prompted interactively.
+ */
+export declare class OpenAIConfigCollector implements ProviderConfigCollector {
+    collectConfig(options: BaseCollectorOptions): Promise<OpenAIConfig>;
+}

package/dist/commands/models/providers/openai.js

@@ -0,0 +1,68 @@
+import inquirer from 'inquirer';
+/**
+ * Configuration collector for OpenAI models.
+ *
+ * Collects the necessary configuration to connect to an OpenAI-compatible API:
+ * - baseUrl: The API endpoint URL (e.g., https://api.openai.com/v1)
+ * - apiKey: The authentication key for the API
+ *
+ * Values can be provided via command-line options or will be prompted interactively.
+ */
+export class OpenAIConfigCollector {
+    async collectConfig(options) {
+        const openaiOptions = options;
+        let baseUrl = openaiOptions.baseUrl;
+        if (!baseUrl) {
+            const answer = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'baseUrl',
+                    message: 'base URL:',
+                    validate: (input) => {
+                        if (!input)
+                            return 'base URL is required';
+                        try {
+                            new URL(input);
+                            return true;
+                        }
+                        catch {
+                            return 'please enter a valid URL';
+                        }
+                    },
+                },
+            ]);
+            baseUrl = answer.baseUrl;
+        }
+        if (!baseUrl) {
+            throw new Error('base URL is required');
+        }
+        baseUrl = baseUrl.replace(/\/$/, '');
+        let apiKey = openaiOptions.apiKey;
+        if (!apiKey) {
+            const answer = await inquirer.prompt([
+                {
+                    type: 'password',
+                    name: 'apiKey',
+                    message: 'API key:',
+                    mask: '*',
+                    validate: (input) => {
+                        if (!input)
+                            return 'API key is required';
+                        return true;
+                    },
+                },
+            ]);
+            apiKey = answer.apiKey;
+        }
+        if (!apiKey) {
+            throw new Error('API key is required');
+        }
+        return {
+            type: 'openai',
+            modelValue: options.model,
+            secretName: '',
+            baseUrl,
+            apiKey,
+        };
+    }
+}

package/dist/commands/models/providers/openai.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/models/providers/openai.spec.js

@@ -0,0 +1,180 @@
+import { jest } from '@jest/globals';
+const mockInquirer = {
+    prompt: jest.fn(),
+};
+jest.unstable_mockModule('inquirer', () => ({
+    default: mockInquirer,
+}));
+const { OpenAIConfigCollector } = await import('./openai.js');
+describe('OpenAIConfigCollector', () => {
+    let collector;
+    beforeEach(() => {
+        collector = new OpenAIConfigCollector();
+        jest.clearAllMocks();
+    });
+    describe('collectConfig', () => {
+        it('uses provided options without prompting', async () => {
+            const options = {
+                model: 'gpt-4o-mini',
+                baseUrl: 'https://api.openai.com/v1',
+                apiKey: 'sk-test-key-12345',
+            };
+            const config = await collector.collectConfig(options);
+            expect(mockInquirer.prompt).not.toHaveBeenCalled();
+            expect(config).toEqual({
+                type: 'openai',
+                modelValue: 'gpt-4o-mini',
+                secretName: '',
+                baseUrl: 'https://api.openai.com/v1',
+                apiKey: 'sk-test-key-12345',
+            });
+        });
+        it('prompts for missing baseUrl', async () => {
+            mockInquirer.prompt.mockResolvedValueOnce({
+                baseUrl: 'https://custom-openai.com',
+            });
+            mockInquirer.prompt.mockResolvedValueOnce({ apiKey: 'sk-custom-key' });
+            const options = {
+                model: 'gpt-4',
+            };
+            const config = await collector.collectConfig(options);
+            expect(mockInquirer.prompt).toHaveBeenCalledWith([
+                expect.objectContaining({
+                    type: 'input',
+                    name: 'baseUrl',
+                    message: 'base URL:',
+                    validate: expect.any(Function),
+                }),
+            ]);
+            expect(config.baseUrl).toBe('https://custom-openai.com');
+        });
+        it('validates baseUrl is required', async () => {
+            mockInquirer.prompt.mockResolvedValueOnce({ baseUrl: '' });
+            const options = {
+                model: 'gpt-4',
+            };
+            // The validation happens in the prompt, but we test the final check
+            await expect(collector.collectConfig(options)).rejects.toThrow('base URL is required');
+        });
+        it('validates baseUrl is a valid URL', async () => {
+            const options = {
+                model: 'gpt-4',
+            };
+            // Get the validate function from the prompt call
+            mockInquirer.prompt.mockImplementationOnce(async (questions) => {
+                const validate = questions[0].validate;
+                // Test invalid URL
+                expect(validate('not-a-url')).toBe('please enter a valid URL');
+                // Test empty string
+                expect(validate('')).toBe('base URL is required');
+                // Test valid URL
+                expect(validate('https://api.openai.com')).toBe(true);
+                return { baseUrl: 'https://api.openai.com' };
+            });
+            mockInquirer.prompt.mockResolvedValueOnce({ apiKey: 'sk-key' });
+            await collector.collectConfig(options);
+        });
+        it('removes trailing slash from baseUrl', async () => {
+            const options = {
+                model: 'gpt-4',
+                baseUrl: 'https://api.openai.com/v1/',
+                apiKey: 'sk-test-key',
+            };
+            const config = await collector.collectConfig(options);
+            expect(config.baseUrl).toBe('https://api.openai.com/v1');
+        });
+        it('prompts for missing apiKey as password field', async () => {
+            mockInquirer.prompt.mockResolvedValueOnce({ apiKey: 'sk-secret-key' });
+            const options = {
+                model: 'gpt-4',
+                baseUrl: 'https://api.openai.com/v1',
+            };
+            const config = await collector.collectConfig(options);
+            expect(mockInquirer.prompt).toHaveBeenCalledWith([
+                expect.objectContaining({
+                    type: 'password',
+                    name: 'apiKey',
+                    message: 'API key:',
+                    mask: '*',
+                    validate: expect.any(Function),
+                }),
+            ]);
+            expect(config.apiKey).toBe('sk-secret-key');
+        });
+        it('validates apiKey is required', async () => {
+            mockInquirer.prompt.mockResolvedValueOnce({ apiKey: '' });
+            const options = {
+                model: 'gpt-4',
+                baseUrl: 'https://api.openai.com/v1',
+            };
+            await expect(collector.collectConfig(options)).rejects.toThrow('API key is required');
+        });
+        it('tests apiKey validation function', async () => {
+            const options = {
+                model: 'gpt-4',
+                baseUrl: 'https://api.openai.com/v1',
+            };
+            // Get the validate function from the prompt call
+            mockInquirer.prompt.mockImplementationOnce(async (questions) => {
+                const validate = questions[0].validate;
+                // Test empty string
+                expect(validate('')).toBe('API key is required');
+                // Test valid key
+                expect(validate('sk-valid-key')).toBe(true);
+                return { apiKey: 'sk-valid-key' };
+            });
+            await collector.collectConfig(options);
+        });
+        it('collects full configuration through interactive prompts', async () => {
+            mockInquirer.prompt.mockResolvedValueOnce({
+                baseUrl: 'https://api.openai.com/v1/',
+            });
+            mockInquirer.prompt.mockResolvedValueOnce({
+                apiKey: 'sk-proj-abc123',
+            });
+            const options = {
+                model: 'gpt-4o',
+            };
+            const config = await collector.collectConfig(options);
+            expect(config).toEqual({
+                type: 'openai',
+                modelValue: 'gpt-4o',
+                secretName: '',
+                baseUrl: 'https://api.openai.com/v1',
+                apiKey: 'sk-proj-abc123',
+            });
+        });
+        it('mixes CLI options and interactive prompts', async () => {
+            mockInquirer.prompt.mockResolvedValueOnce({
+                apiKey: 'sk-prompted-key',
+            });
+            const options = {
+                model: 'gpt-3.5-turbo',
+                baseUrl: 'https://custom-api.com/v1',
+            };
+            const config = await collector.collectConfig(options);
+            expect(config).toEqual({
+                type: 'openai',
+                modelValue: 'gpt-3.5-turbo',
+                secretName: '',
+                baseUrl: 'https://custom-api.com/v1',
+                apiKey: 'sk-prompted-key',
+            });
+        });
+        it('handles custom OpenAI-compatible endpoints', async () => {
+            const options = {
+                model: 'llama-3-8b',
+                baseUrl: 'https://localhost:8080/v1',
+                apiKey: 'local-key-123',
+            };
+            const config = await collector.collectConfig(options);
+            expect(config).toEqual({
+                type: 'openai',
+                modelValue: 'llama-3-8b',
+                secretName: '',
+                baseUrl: 'https://localhost:8080/v1',
+                apiKey: 'local-key-123',
+            });
+        });
+    });
+});

package/dist/commands/models/providers/types.d.ts

@@ -0,0 +1,51 @@
+import type { ProviderConfig } from './index.js';
+/**
+ * Base configuration shared by all model providers.
+ */
+export interface BaseProviderConfig {
+    type: string;
+    modelValue: string;
+    secretName: string;
+}
+/**
+ * Common options available to all providers collectors.
+ *
+ * Can be extended with provider-specific options to grant more flexibility when configuring models on different providers.
+ *
+ * @field model - Model name (e.g., 'gpt-4o-mini')
+ * @field type - Model provider type (e.g., 'azure', 'openai', 'bedrock')
+ */
+export interface BaseCollectorOptions {
+    /**
+     * Model name (e.g., 'gpt-4o-mini')
+     */
+    model?: string;
+    /**
+     * Model provider type (e.g., 'azure', 'openai', 'bedrock')
+     */
+    type?: string;
+    [key: string]: unknown;
+}
+/**
+ * Provider configuration collector interface.
+ *
+ * A collector is responsible for gathering all the necessary configuration
+ * parameters for a specific model provider (OpenAI, Azure, Bedrock, etc.).
+ * It handles the interactive prompting of missing values and validation
+ * of user inputs, ensuring all required fields are collected before
+ * creating the model resource.
+ *
+ * The collector pattern allows each provider to define its own specific
+ * configuration requirements and prompts without affecting other providers.
+ */
+export interface ProviderConfigCollector {
+    /**
+     * Collects provider-specific configuration by prompting for any missing values.
+     *
+     * @param options - Options object that may contain pre-filled values.
+     *                  Each collector extracts only the fields it needs.
+     * @returns A promise that resolves to a complete provider configuration with all required fields
+     * @throws Error if a required field cannot be obtained or validation fails
+     */
+    collectConfig(options: BaseCollectorOptions): Promise<ProviderConfig>;
+}

package/dist/commands/models/providers/types.js

@@ -0,0 +1 @@
+export {};

package/dist/commands/queries/delete.d.ts

@@ -0,0 +1,7 @@
+interface DeleteQueryOptions {
+    all?: boolean;
+}
+export declare const MISSING_NAME_OR_ALL_ERROR = "either provide a query name or use --all flag";
+export declare const BOTH_NAME_AND_ALL_ERROR = "cannot use query name and --all flag together";
+export declare function deleteQuery(name: string | undefined, options: DeleteQueryOptions): Promise<void>;
+export {};

package/dist/commands/queries/delete.js

@@ -0,0 +1,24 @@
+import output from '../../lib/output.js';
+import { ExitCodes } from '../../lib/errors.js';
+import { deleteResource } from '../../lib/kubectl.js';
+import { InvalidArgumentError } from 'commander';
+export const MISSING_NAME_OR_ALL_ERROR = 'either provide a query name or use --all flag';
+export const BOTH_NAME_AND_ALL_ERROR = 'cannot use query name and --all flag together';
+function assertDeleteOptionsValid(name, options) {
+    if (!name && !options.all) {
+        throw new InvalidArgumentError(MISSING_NAME_OR_ALL_ERROR);
+    }
+    if (name && options.all) {
+        throw new InvalidArgumentError(BOTH_NAME_AND_ALL_ERROR);
+    }
+}
+export async function deleteQuery(name, options) {
+    try {
+        assertDeleteOptionsValid(name, options);
+        await deleteResource('queries', name, options);
+    }
+    catch (error) {
+        output.error('deleting query:', error instanceof Error ? error.message : error);
+        process.exit(ExitCodes.CliError);
+    }
+}

package/dist/commands/queries/delete.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/queries/delete.spec.js

@@ -0,0 +1,74 @@
+import { jest } from '@jest/globals';
+import output from '../../lib/output.js';
+const mockExeca = jest.fn();
+jest.unstable_mockModule('execa', () => ({
+    execa: mockExeca,
+}));
+const { createQueriesCommand } = await import('./index.js');
+const { deleteQuery, BOTH_NAME_AND_ALL_ERROR, MISSING_NAME_OR_ALL_ERROR } = await import('./delete.js');
+describe('queries delete command', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        console.log = jest.fn();
+        jest.spyOn(output, 'warning').mockImplementation(() => { });
+        jest.spyOn(output, 'error').mockImplementation(() => { });
+        jest.spyOn(process, 'exit').mockImplementation(() => undefined);
+    });
+    it('should delete a query by name', async () => {
+        mockExeca.mockResolvedValue({
+            stdout: '',
+        });
+        const command = createQueriesCommand({});
+        await command.parseAsync(['node', 'test', 'delete', 'query-1']);
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['delete', 'queries', 'query-1'], { stdio: 'pipe' });
+        expect(output.warning).not.toHaveBeenCalled();
+        expect(process.exit).not.toHaveBeenCalled();
+    });
+    it('should delete all queries with --all flag', async () => {
+        mockExeca.mockResolvedValue({
+            stdout: '',
+        });
+        const command = createQueriesCommand({});
+        await command.parseAsync(['node', 'test', 'delete', '--all']);
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['delete', 'queries', '--all'], { stdio: 'pipe' });
+        expect(output.warning).not.toHaveBeenCalled();
+        expect(process.exit).not.toHaveBeenCalled();
+    });
+});
+describe('deleteQuery function', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.spyOn(output, 'error').mockImplementation(() => { });
+        jest.spyOn(process, 'exit').mockImplementation(() => undefined);
+    });
+    it('should throw error when neither name nor --all flag is provided', async () => {
+        await deleteQuery(undefined, {});
+        expect(output.error).toHaveBeenCalledWith(expect.anything(), expect.stringMatching(MISSING_NAME_OR_ALL_ERROR));
+        expect(process.exit).toHaveBeenCalledWith(1);
+    });
+    it('should throw error when both name and --all flag are provided', async () => {
+        await deleteQuery('my-query', { all: true });
+        expect(output.error).toHaveBeenCalledWith(expect.anything(), expect.stringMatching(BOTH_NAME_AND_ALL_ERROR));
+        expect(process.exit).toHaveBeenCalledWith(1);
+    });
+    it('should handle deletion errors gracefully', async () => {
+        mockExeca.mockRejectedValue(new Error('query not found'));
+        await deleteQuery('nonexistent-query', {});
+        expect(output.error).toHaveBeenCalledWith('deleting query:', 'query not found');
+        expect(process.exit).toHaveBeenCalledWith(1);
+    });
+    it('should call deleteResource with query name', async () => {
+        mockExeca.mockResolvedValue({
+            stdout: '',
+        });
+        await deleteQuery('my-query', {});
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['delete', 'queries', 'my-query'], { stdio: 'pipe' });
+    });
+    it('should delete all queries when all option is true', async () => {
+        mockExeca.mockResolvedValue({
+            stdout: '',
+        });
+        await deleteQuery(undefined, { all: true });
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['delete', 'queries', '--all'], { stdio: 'pipe' });
+    });
+});

package/dist/commands/queries/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+import type { ArkConfig } from '../../lib/config.js';
+export declare function createQueriesCommand(_: ArkConfig): Command;

package/dist/commands/queries/index.js

@@ -0,0 +1,108 @@
+import { Command } from 'commander';
+import { marked } from 'marked';
+// @ts-ignore - no types available
+import TerminalRenderer from 'marked-terminal';
+import output from '../../lib/output.js';
+import { ExitCodes } from '../../lib/errors.js';
+import { getResource, replaceResource } from '../../lib/kubectl.js';
+import { listQueries } from './list.js';
+import { deleteQuery } from './delete.js';
+function renderMarkdown(content) {
+    if (process.stdout.isTTY) {
+        marked.setOptions({
+            // @ts-ignore - TerminalRenderer types are incomplete
+            renderer: new TerminalRenderer({
+                showSectionPrefix: false,
+                reflowText: true,
+                // @ts-ignore - preserveNewlines exists but not in types
+                preserveNewlines: true,
+            }),
+        });
+        return marked(content);
+    }
+    return content;
+}
+async function getQuery(name, options) {
+    try {
+        const query = await getResource('queries', name);
+        if (options.response) {
+            if (query.status?.responses && query.status.responses.length > 0) {
+                const response = query.status.responses[0];
+                if (options.output === 'markdown') {
+                    console.log(renderMarkdown(response.content || ''));
+                }
+                else {
+                    console.log(JSON.stringify(response, null, 2));
+                }
+            }
+            else {
+                output.warning('No response available');
+            }
+        }
+        else if (options.output === 'markdown') {
+            if (query.status?.responses && query.status.responses.length > 0) {
+                console.log(renderMarkdown(query.status.responses[0].content || ''));
+            }
+            else {
+                output.warning('No response available');
+            }
+        }
+        else {
+            console.log(JSON.stringify(query, null, 2));
+        }
+    }
+    catch (error) {
+        output.error('fetching query:', error instanceof Error ? error.message : error);
+        process.exit(ExitCodes.CliError);
+    }
+}
+export function createQueriesCommand(_) {
+    const queriesCommand = new Command('queries');
+    queriesCommand
+        .description('List all queries')
+        .option('-o, --output <format>', 'output format (json or text)', 'text')
+        .option('--sort-by <field>', 'sort by kubernetes field (e.g., .metadata.name)')
+        .action(async (options) => {
+        await listQueries(options);
+    });
+    const getCommand = new Command('get');
+    getCommand
+        .description('Get a specific query (@latest for most recent)')
+        .argument('<name>', 'Query name or @latest')
+        .option('-o, --output <format>', 'output format (json, markdown)', 'json')
+        .option('-r, --response', 'show only the response content', false)
+        .action(async (name, options) => {
+        await getQuery(name, options);
+    });
+    queriesCommand.addCommand(getCommand);
+    const deleteCommand = new Command('delete');
+    deleteCommand
+        .description('Delete a query')
+        .argument('[name]', 'Query name')
+        .option('--all', 'delete all queries', false)
+        .action(async (name, options) => {
+        await deleteQuery(name, options);
+    });
+    queriesCommand.addCommand(deleteCommand);
+    const resubmitCommand = new Command('resubmit');
+    resubmitCommand
+        .description('Resubmit a query by clearing its status (@latest for most recent)')
+        .argument('<name>', 'Query name or @latest')
+        .action(async (name) => {
+        try {
+            const query = await getResource('queries', name);
+            const queryWithoutStatus = {
+                ...query,
+                status: undefined,
+            };
+            await replaceResource(queryWithoutStatus);
+            output.success(`Query '${query.metadata.name}' resubmitted`);
+        }
+        catch (error) {
+            output.error('resubmitting query:', error instanceof Error ? error.message : error);
+            process.exit(ExitCodes.CliError);
+        }
+    });
+    queriesCommand.addCommand(resubmitCommand);
+    return queriesCommand;
+}

package/dist/commands/queries/list.d.ts

@@ -0,0 +1,6 @@
+interface ListQueriesOptions {
+    output?: string;
+    sortBy?: string;
+}
+export declare function listQueries(options: ListQueriesOptions): Promise<void>;
+export {};

package/dist/commands/queries/list.js

@@ -0,0 +1,66 @@
+import chalk from 'chalk';
+import output from '../../lib/output.js';
+import { ExitCodes } from '../../lib/errors.js';
+import { listResources } from '../../lib/kubectl.js';
+import { assertSupportedOutputFormat } from './validation.js';
+// Output format constants
+const OUTPUT_FORMAT_JSON = 'json';
+// Query phase constants
+const PHASE_DONE = 'done';
+const PHASE_RUNNING = 'running';
+const PHASE_ERROR = 'error';
+const PHASE_UNKNOWN = 'unknown';
+// Column padding
+const COLUMN_PADDING = 2;
+const MIN_NAME_LENGTH = 4;
+function getStatusColor(status) {
+    switch (status) {
+        case PHASE_DONE:
+            return chalk.green;
+        case PHASE_RUNNING:
+            return chalk.blue;
+        case PHASE_ERROR:
+            return chalk.red;
+        default:
+            return chalk.yellow;
+    }
+}
+function printTableHeader(maxNameLength) {
+    const paddedHeaderLength = maxNameLength + COLUMN_PADDING;
+    const header = `${'NAME'.padEnd(paddedHeaderLength)}${'STATUS'}`;
+    console.log(header);
+}
+function printTableRow(query, maxNameLength) {
+    const status = query.status?.phase || PHASE_UNKNOWN;
+    const statusColor = getStatusColor(status);
+    const paddedNameLength = maxNameLength + COLUMN_PADDING;
+    console.log(`${query.metadata.name.padEnd(paddedNameLength)}${statusColor(status)}`);
+}
+function printResult(queries, options) {
+    if (options.output === OUTPUT_FORMAT_JSON) {
+        console.log(JSON.stringify(queries, null, 2));
+        return;
+    }
+    if (queries.length === 0) {
+        output.warning('no queries available');
+        return;
+    }
+    const maxNameLength = Math.max(MIN_NAME_LENGTH, ...queries.map((q) => q.metadata.name.length));
+    printTableHeader(maxNameLength);
+    queries.forEach((query) => {
+        printTableRow(query, maxNameLength);
+    });
+}
+export async function listQueries(options) {
+    try {
+        assertSupportedOutputFormat(options.output);
+        const queries = await listResources('queries', {
+            sortBy: options.sortBy,
+        });
+        printResult(queries, options);
+    }
+    catch (error) {
+        output.error('fetching queries:', error instanceof Error ? error.message : error);
+        process.exit(ExitCodes.CliError);
+    }
+}

package/dist/commands/queries/list.spec.d.ts

@@ -0,0 +1 @@
+export {};