@guildai/cli 0.6.0 → 0.6.1

package/dist/commands/integration/operation/create.js

@@ -0,0 +1,163 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { readFileSync, existsSync } from 'fs';
+import { GuildAPIClient } from '../../../lib/api-client.js';
+import { getAuthToken } from '../../../lib/auth.js';
+import { handleAxiosError } from '../../../lib/errors.js';
+import { getOutputMode } from '../../../lib/output-mode.js';
+import { createOutputWriter } from '../../../lib/output.js';
+import { resolveVersionId } from '../../../lib/integration-helpers.js';
+import { isInteractive } from '../../../lib/stdin.js';
+const VALID_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'];
+export function createIntegrationOperationCreateCommand() {
+    const cmd = new Command('create');
+    cmd
+        .description('Create operation(s) for an integration version')
+        .argument('<id_or_name>', 'Integration ID or name (owner~name)')
+        .option('--version <semver>', 'Specific version, e.g. 1.0.0')
+        .option('--operation <name>', 'Operation identifier, e.g. list_users')
+        .option('--method <method>', 'HTTP method: GET, POST, PUT, PATCH, DELETE')
+        .option('--path <path>', 'REST path, e.g. /{owner}/{repo}/issues')
+        .option('--summary <text>', 'Short description of the operation')
+        .option('--tags <tags>', 'Comma-separated tags, e.g. users,admin')
+        .option('--input-body-schema <file>', 'Path to JSON file for request body schema')
+        .option('--output-body-schema <file>', 'Path to JSON file for response body schema')
+        .option('--openapi <file>', 'Path to OpenAPI spec file (YAML or JSON)')
+        .action(async (identifier, options) => {
+        const output = createOutputWriter();
+        try {
+            const token = await getAuthToken();
+            if (!token) {
+                output.error('Not authenticated. Please log in first.', 'Run: guild auth login');
+                process.exit(1);
+            }
+            const client = new GuildAPIClient();
+            const versionId = await resolveVersionId(client, identifier, options.version);
+            if (options.openapi) {
+                // OpenAPI mode
+                if (!existsSync(options.openapi)) {
+                    output.error(`Error: File not found: ${options.openapi}`);
+                    process.exit(1);
+                }
+                const content = readFileSync(options.openapi, 'utf-8');
+                const response = await client.post(`/integration_versions/${versionId}/endpoint_generators`, { type: 'openapi', content });
+                if (getOutputMode() === 'json') {
+                    output.data(response);
+                }
+                else {
+                    console.log(chalk.green('OpenAPI operation generation triggered'));
+                    console.log();
+                    console.log("Operations will be generated asynchronously. Use 'guild integration operation list' to check results.");
+                }
+            }
+            else {
+                // Individual operation mode — prompt for missing fields in TTY
+                let operation = options.operation;
+                let method = options.method;
+                let operationPath = options.path;
+                if (isInteractive()) {
+                    if (!operation) {
+                        const a = await inquirer.prompt([
+                            {
+                                type: 'input',
+                                name: 'val',
+                                message: 'Operation name (e.g. list_users):',
+                            },
+                        ]);
+                        operation = a.val;
+                    }
+                    if (!method) {
+                        const a = await inquirer.prompt([
+                            {
+                                type: 'list',
+                                name: 'val',
+                                message: 'HTTP method:',
+                                choices: VALID_METHODS,
+                            },
+                        ]);
+                        method = a.val;
+                    }
+                    if (!operationPath) {
+                        const a = await inquirer.prompt([
+                            { type: 'input', name: 'val', message: 'REST path (e.g. /users):' },
+                        ]);
+                        operationPath = a.val;
+                    }
+                }
+                const missing = [];
+                if (!operation)
+                    missing.push('--operation');
+                if (!method)
+                    missing.push('--method');
+                if (!operationPath)
+                    missing.push('--path');
+                if (missing.length > 0) {
+                    output.error(`Error: ${missing.join(', ')} are required when not using --openapi`);
+                    process.exit(1);
+                }
+                method = method.toUpperCase();
+                if (!VALID_METHODS.includes(method)) {
+                    output.error(`Error: Invalid HTTP method '${method}'`, `Valid methods: ${VALID_METHODS.join(', ')}`);
+                    process.exit(1);
+                }
+                const body = {
+                    operation,
+                    method,
+                    path: operationPath,
+                };
+                let summary = options.summary;
+                if (!summary && isInteractive()) {
+                    const a = await inquirer.prompt([
+                        { type: 'input', name: 'val', message: 'Summary (optional):' },
+                    ]);
+                    if (a.val)
+                        summary = a.val;
+                }
+                if (summary) {
+                    body.summary = summary;
+                }
+                if (options.tags) {
+                    body.tags = options.tags.split(',').map((t) => t.trim());
+                }
+                if (options.inputBodySchema) {
+                    if (!existsSync(options.inputBodySchema)) {
+                        output.error(`Error: File not found: ${options.inputBodySchema}`);
+                        process.exit(1);
+                    }
+                    body.input_body_type = JSON.parse(readFileSync(options.inputBodySchema, 'utf-8'));
+                }
+                if (options.outputBodySchema) {
+                    if (!existsSync(options.outputBodySchema)) {
+                        output.error(`Error: File not found: ${options.outputBodySchema}`);
+                        process.exit(1);
+                    }
+                    body.output_body_type = JSON.parse(readFileSync(options.outputBodySchema, 'utf-8'));
+                }
+                const response = await client.post(`/integration_versions/${versionId}/endpoints`, body);
+                if (getOutputMode() === 'json') {
+                    output.data(response);
+                }
+                else {
+                    console.log(chalk.green('Operation created successfully'));
+                    console.log();
+                    console.log(`  ${'Operation'.padEnd(12)}${response.operation}`);
+                    console.log(`  ${'Method'.padEnd(12)}${response.method}`);
+                    console.log(`  ${'Path'.padEnd(12)}${response.path}`);
+                    if (response.summary) {
+                        console.log(`  ${'Summary'.padEnd(12)}${response.summary}`);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            const formattedError = handleAxiosError(error);
+            output.error(`Failed to create operation: ${formattedError.details}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=create.js.map

package/dist/commands/integration/operation/list.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function createIntegrationOperationListCommand(): Command;
+//# sourceMappingURL=list.d.ts.map

package/dist/commands/integration/operation/list.js

@@ -0,0 +1,83 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { GuildAPIClient } from '../../../lib/api-client.js';
+import { getAuthToken } from '../../../lib/auth.js';
+import { handleAxiosError } from '../../../lib/errors.js';
+import { getOutputMode } from '../../../lib/output-mode.js';
+import { createOutputWriter } from '../../../lib/output.js';
+import { resolveVersionId } from '../../../lib/integration-helpers.js';
+import { Table } from '../../../lib/table.js';
+export function createIntegrationOperationListCommand() {
+    const cmd = new Command('list');
+    cmd
+        .description('List operations for an integration version')
+        .argument('<id_or_name>', 'Integration ID or name (owner~name)')
+        .option('--version <semver>', 'Specific version, e.g. 1.0.0')
+        .option('--limit <number>', 'Number of results to return', '100')
+        .option('--offset <number>', 'Offset for pagination', '0')
+        .action(async (identifier, options) => {
+        const output = createOutputWriter();
+        try {
+            const token = await getAuthToken();
+            if (!token) {
+                output.error('Not authenticated. Please log in first.', 'Run: guild auth login');
+                process.exit(1);
+            }
+            const client = new GuildAPIClient();
+            const versionId = await resolveVersionId(client, identifier, options.version);
+            const params = new URLSearchParams();
+            params.append('limit', options.limit);
+            params.append('offset', options.offset);
+            const response = await client.get(`/integration_versions/${versionId}/endpoints?${params.toString()}`);
+            if (getOutputMode() === 'json') {
+                output.data(response);
+            }
+            else {
+                if (response.items.length === 0) {
+                    console.log(chalk.dim('No operations found'));
+                    return;
+                }
+                console.log(chalk.bold('Operations'));
+                console.log();
+                const table = new Table({
+                    columns: [
+                        { name: 'operation', title: 'OPERATION', alignment: 'left' },
+                        {
+                            name: 'method',
+                            title: 'METHOD',
+                            alignment: 'left',
+                            color: 'cyan',
+                        },
+                        { name: 'path', title: 'PATH', alignment: 'left' },
+                    ],
+                });
+                response.items.forEach((ep) => {
+                    table.addRow({
+                        operation: ep.operation,
+                        method: ep.method,
+                        path: ep.path,
+                    });
+                });
+                table.printTable();
+                const showing = Math.min(response.pagination.limit, response.items.length);
+                if (response.pagination.has_more) {
+                    const nextOffset = response.pagination.offset + response.pagination.limit;
+                    console.log(`\nShowing ${showing} of ${response.pagination.total_count} operations. ` +
+                        chalk.dim(`Use --offset ${nextOffset} to see more.`));
+                }
+                else if (response.pagination.total_count > showing) {
+                    console.log(chalk.dim(`\nShowing ${showing} of ${response.pagination.total_count} operations`));
+                }
+            }
+        }
+        catch (error) {
+            const formattedError = handleAxiosError(error);
+            output.error(`Failed to list operations: ${formattedError.details}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=list.js.map

package/dist/commands/integration/update.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function createIntegrationUpdateCommand(): Command;
+//# sourceMappingURL=update.d.ts.map

package/dist/commands/integration/update.js

@@ -0,0 +1,139 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { GuildAPIClient } from '../../lib/api-client.js';
+import { getAuthToken } from '../../lib/auth.js';
+import { handleAxiosError } from '../../lib/errors.js';
+import { getOutputMode } from '../../lib/output-mode.js';
+import { createOutputWriter } from '../../lib/output.js';
+function formatUpdatedIntegration(integration) {
+    console.log(chalk.green('Integration updated successfully'));
+    console.log();
+    console.log(`  ${'Name'.padEnd(15)}${integration.name}`);
+    console.log(`  ${'Description'.padEnd(15)}${integration.description || chalk.dim('—')}`);
+    console.log(`  ${'Visibility'.padEnd(15)}${integration.is_public ? 'public' : 'internal'}`);
+    console.log(`  ${'Owner'.padEnd(15)}${integration.owner?.name || chalk.dim('—')}`);
+    console.log(`  ${'Base URL'.padEnd(15)}${integration.protocol_config.base_url}`);
+    const scheme = integration.auth_config.auth_scheme === 'API_KEY' ? 'API Key' : 'OAuth 2.0';
+    console.log(`  ${'Auth Scheme'.padEnd(15)}${scheme}`);
+    if (integration.auth_config.token_header_template) {
+        console.log(`  ${'Header'.padEnd(15)}${integration.auth_config.token_header_template}`);
+    }
+    if (integration.webhook_config) {
+        console.log(`  ${'Webhooks'.padEnd(15)}Enabled`);
+    }
+    else {
+        console.log(`  ${'Webhooks'.padEnd(15)}${chalk.dim('Not configured')}`);
+    }
+}
+export function createIntegrationUpdateCommand() {
+    const cmd = new Command('update');
+    cmd
+        .description('Update an integration')
+        .argument('<id_or_name>', 'Integration ID or name')
+        .option('--description <text>', 'Update description')
+        .option('--base-url <url>', 'Update REST base URL')
+        .option('--public', 'Make integration public')
+        .option('--no-public', 'Make integration private')
+        .option('--header-template <template>', 'Update API Key header template')
+        .option('--install-url <url>', 'Update OAuth authorization URL')
+        .option('--token-url <url>', 'Update OAuth token URL')
+        .option('--token-content-type <type>', 'Update OAuth token request content type')
+        .option('--client-secret <secret>', 'Update OAuth client secret')
+        .option('--webhook-events <events>', 'Update webhook events as JSON')
+        .action(async (identifier, options) => {
+        const output = createOutputWriter();
+        try {
+            const token = await getAuthToken();
+            if (!token) {
+                output.error('Not authenticated. Please log in first.', 'Run: guild auth login');
+                process.exit(1);
+            }
+            const client = new GuildAPIClient();
+            // Build partial update body
+            const body = {};
+            let hasUpdates = false;
+            if (options.description !== undefined) {
+                body.description = options.description;
+                hasUpdates = true;
+            }
+            if (options.public !== undefined) {
+                body.is_public = options.public;
+                hasUpdates = true;
+            }
+            if (options.baseUrl !== undefined) {
+                body.protocol_config = { base_url: options.baseUrl };
+                hasUpdates = true;
+            }
+            // Auth config updates need the discriminator
+            const hasAuthUpdate = options.headerTemplate !== undefined ||
+                options.installUrl !== undefined ||
+                options.tokenUrl !== undefined ||
+                options.tokenContentType !== undefined ||
+                options.clientSecret !== undefined;
+            if (hasAuthUpdate) {
+                // Fetch integration to determine current auth scheme
+                const current = await client.get(`/integrations/${identifier}`);
+                const scheme = current.auth_config.auth_scheme;
+                if (scheme === 'API_KEY') {
+                    const authConfig = {
+                        auth_scheme: 'API_KEY',
+                    };
+                    if (options.headerTemplate !== undefined) {
+                        authConfig.token_header_template = options.headerTemplate;
+                    }
+                    body.auth_config = authConfig;
+                }
+                else {
+                    const authConfig = {
+                        auth_scheme: 'OAUTH',
+                    };
+                    if (options.installUrl !== undefined) {
+                        authConfig.install_url = options.installUrl;
+                    }
+                    if (options.tokenUrl !== undefined) {
+                        authConfig.token_url = options.tokenUrl;
+                    }
+                    if (options.tokenContentType !== undefined) {
+                        authConfig.token_url_content_type = options.tokenContentType;
+                    }
+                    if (options.clientSecret !== undefined) {
+                        authConfig.client_secret = options.clientSecret;
+                    }
+                    body.auth_config = authConfig;
+                }
+                hasUpdates = true;
+            }
+            if (options.webhookEvents !== undefined) {
+                try {
+                    const events = JSON.parse(options.webhookEvents);
+                    body.webhook_config = { events };
+                }
+                catch {
+                    output.error(`Error: Invalid JSON for --webhook-events: ${options.webhookEvents}`);
+                    process.exit(1);
+                }
+                hasUpdates = true;
+            }
+            if (!hasUpdates) {
+                output.error('Error: No update options provided. Use --help to see available options.');
+                process.exit(1);
+            }
+            const response = await client.patch(`/integrations/${identifier}`, body);
+            if (getOutputMode() === 'json') {
+                output.data(response);
+            }
+            else {
+                formatUpdatedIntegration(response);
+            }
+        }
+        catch (error) {
+            const formattedError = handleAxiosError(error);
+            output.error(`Failed to update integration: ${formattedError.details}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=update.js.map

package/dist/commands/integration/version/build.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function createIntegrationVersionBuildCommand(): Command;
+//# sourceMappingURL=build.d.ts.map

package/dist/commands/integration/version/build.js

@@ -0,0 +1,86 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { GuildAPIClient } from '../../../lib/api-client.js';
+import { getAuthToken } from '../../../lib/auth.js';
+import { handleAxiosError } from '../../../lib/errors.js';
+import { getOutputMode } from '../../../lib/output-mode.js';
+import { createOutputWriter } from '../../../lib/output.js';
+import { createSpinner } from '../../../lib/progress.js';
+import { resolveLatestDraftId } from '../../../lib/integration-helpers.js';
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export function createIntegrationVersionBuildCommand() {
+    const cmd = new Command('build');
+    cmd
+        .description('Build (validate) a draft version')
+        .argument('<id_or_name>', 'Integration name (owner~name, defaults to latest draft) or version UUID')
+        .requiredOption('--version-number <semver>', 'Semantic version number to assign, e.g. 1.0.0')
+        .action(async (identifier, options) => {
+        const output = createOutputWriter();
+        try {
+            const token = await getAuthToken();
+            if (!token) {
+                output.error('Not authenticated. Please log in first.', 'Run: guild auth login');
+                process.exit(1);
+            }
+            const client = new GuildAPIClient();
+            // Resolve version ID: UUID directly, or owner~name → latest draft
+            let versionId;
+            if (UUID_REGEX.test(identifier)) {
+                versionId = identifier;
+            }
+            else {
+                versionId = await resolveLatestDraftId(client, identifier);
+            }
+            const buildResponse = await client.post(`/integration_versions/${versionId}/build`, {
+                version_number: options.versionNumber,
+            });
+            if (getOutputMode() === 'json') {
+                output.data(buildResponse);
+                return;
+            }
+            // Poll until build completes
+            const spinner = createSpinner(`Building version ${options.versionNumber}...`);
+            spinner.start();
+            const maxAttempts = 60;
+            let attempt = 0;
+            let finalVersion = null;
+            while (attempt < maxAttempts) {
+                await new Promise((r) => setTimeout(r, 3000));
+                attempt++;
+                const version = await client.get(`/integration_versions/${versionId}`);
+                if (version.validation_status === 'PASSED' ||
+                    version.validation_status === 'FAILED') {
+                    finalVersion = version;
+                    break;
+                }
+                spinner.text = `Building version ${options.versionNumber}... (${attempt}/${maxAttempts})`;
+            }
+            if (!finalVersion) {
+                spinner.fail('Build timed out');
+                process.exit(1);
+            }
+            if (finalVersion.validation_status === 'PASSED') {
+                spinner.succeed('Build passed');
+            }
+            else {
+                spinner.fail('Build failed');
+            }
+            console.log();
+            console.log(`  ${'Version ID'.padEnd(17)}${finalVersion.id}`);
+            console.log(`  ${'Version Number'.padEnd(17)}${finalVersion.version_number || chalk.dim('—')}`);
+            console.log(`  ${'Status'.padEnd(17)}${finalVersion.validation_status === 'PASSED' ? 'Valid' : 'Failed'}`);
+            if (finalVersion.validation_status === 'FAILED') {
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            const formattedError = handleAxiosError(error);
+            output.error(`Failed to build version: ${formattedError.details}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=build.js.map

package/dist/commands/integration/version/create.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function createIntegrationVersionCreateCommand(): Command;
+//# sourceMappingURL=create.d.ts.map

package/dist/commands/integration/version/create.js

@@ -0,0 +1,45 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { GuildAPIClient } from '../../../lib/api-client.js';
+import { getAuthToken } from '../../../lib/auth.js';
+import { handleAxiosError } from '../../../lib/errors.js';
+import { getOutputMode } from '../../../lib/output-mode.js';
+import { createOutputWriter } from '../../../lib/output.js';
+export function createIntegrationVersionCreateCommand() {
+    const cmd = new Command('create');
+    cmd
+        .description('Create a new draft version')
+        .argument('<id_or_name>', 'Integration ID or name')
+        .action(async (identifier) => {
+        const output = createOutputWriter();
+        try {
+            const token = await getAuthToken();
+            if (!token) {
+                output.error('Not authenticated. Please log in first.', 'Run: guild auth login');
+                process.exit(1);
+            }
+            const client = new GuildAPIClient();
+            const response = await client.post(`/integrations/${identifier}/versions`, {});
+            if (getOutputMode() === 'json') {
+                output.data(response);
+            }
+            else {
+                console.log(chalk.green('Version created successfully'));
+                console.log();
+                console.log(`  ${'Version ID'.padEnd(15)}${response.id}`);
+                console.log(`  ${'Status'.padEnd(15)}Draft`);
+                console.log(`  ${'Author'.padEnd(15)}${response.author?.name || chalk.dim('—')}`);
+                console.log(`  ${'Created'.padEnd(15)}just now`);
+            }
+        }
+        catch (error) {
+            const formattedError = handleAxiosError(error);
+            output.error(`Failed to create version: ${formattedError.details}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=create.js.map

package/dist/commands/integration/version/get.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function createIntegrationVersionGetCommand(): Command;
+//# sourceMappingURL=get.d.ts.map

package/dist/commands/integration/version/get.js

@@ -0,0 +1,72 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { GuildAPIClient } from '../../../lib/api-client.js';
+import { getAuthToken } from '../../../lib/auth.js';
+import { handleAxiosError } from '../../../lib/errors.js';
+import { getOutputMode } from '../../../lib/output-mode.js';
+import { createOutputWriter } from '../../../lib/output.js';
+import { resolveVersionId } from '../../../lib/integration-helpers.js';
+function formatDate(dateStr) {
+    return new Date(dateStr).toLocaleString('en-US', {
+        month: 'short',
+        day: 'numeric',
+        year: 'numeric',
+        hour: 'numeric',
+        minute: '2-digit',
+    });
+}
+function formatValidationStatus(status) {
+    switch (status) {
+        case 'PASSED':
+            return 'Valid';
+        case 'FAILED':
+            return 'Failed';
+        case 'RUNNING':
+            return 'Building';
+        default:
+            return '—';
+    }
+}
+export function createIntegrationVersionGetCommand() {
+    const cmd = new Command('get');
+    cmd
+        .description('Get version details')
+        .argument('<id_or_name>', 'Integration ID or name (owner~name)')
+        .option('--version <semver>', 'Specific version, e.g. 1.0.0')
+        .action(async (identifier, options) => {
+        const output = createOutputWriter();
+        try {
+            const token = await getAuthToken();
+            if (!token) {
+                output.error('Not authenticated. Please log in first.', 'Run: guild auth login');
+                process.exit(1);
+            }
+            const client = new GuildAPIClient();
+            const versionId = await resolveVersionId(client, identifier, options.version);
+            const response = await client.get(`/integration_versions/${versionId}`);
+            if (getOutputMode() === 'json') {
+                output.data(response);
+            }
+            else {
+                const versionDisplay = response.version_number || 'Draft';
+                const integrationName = response.integration?.name || identifier;
+                console.log(chalk.bold(`${integrationName} - ${versionDisplay}`));
+                console.log();
+                console.log(`  ${'Status'.padEnd(15)}${formatValidationStatus(response.validation_status)}`);
+                console.log(`  ${'Author'.padEnd(15)}${response.author?.name || chalk.dim('—')}`);
+                console.log(`  ${'Published'.padEnd(15)}${response.published_at ? formatDate(response.published_at) : chalk.dim('—')}`);
+                console.log(`  ${'Created'.padEnd(15)}${formatDate(response.created_at)}`);
+                console.log(`  ${'Last Updated'.padEnd(15)}${formatDate(response.updated_at)}`);
+            }
+        }
+        catch (error) {
+            const formattedError = handleAxiosError(error);
+            output.error(`Failed to get version: ${formattedError.details}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=get.js.map

package/dist/commands/integration/version/list.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function createIntegrationVersionListCommand(): Command;
+//# sourceMappingURL=list.d.ts.map

package/dist/commands/integration/version/list.js

@@ -0,0 +1,44 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+import { Command } from 'commander';
+import { GuildAPIClient } from '../../../lib/api-client.js';
+import { getAuthToken } from '../../../lib/auth.js';
+import { handleAxiosError } from '../../../lib/errors.js';
+import { getOutputMode } from '../../../lib/output-mode.js';
+import { createOutputWriter, formatIntegrationVersionTable, } from '../../../lib/output.js';
+export function createIntegrationVersionListCommand() {
+    const cmd = new Command('list');
+    cmd
+        .description('List integration versions')
+        .argument('<id_or_name>', 'Integration ID or name')
+        .option('--limit <number>', 'Number of results to return', '20')
+        .option('--offset <number>', 'Offset for pagination', '0')
+        .action(async (identifier, options) => {
+        const output = createOutputWriter();
+        try {
+            const token = await getAuthToken();
+            if (!token) {
+                output.error('Not authenticated. Please log in first.', 'Run: guild auth login');
+                process.exit(1);
+            }
+            const client = new GuildAPIClient();
+            const params = new URLSearchParams();
+            params.append('limit', options.limit);
+            params.append('offset', options.offset);
+            const response = await client.get(`/integrations/${identifier}/versions?${params.toString()}`);
+            if (getOutputMode() === 'json') {
+                output.data(response);
+            }
+            else {
+                formatIntegrationVersionTable(response.items, response.pagination, identifier);
+            }
+        }
+        catch (error) {
+            const formattedError = handleAxiosError(error);
+            output.error(`Failed to list versions: ${formattedError.details}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=list.js.map