@guildai/cli 0.5.13 → 0.6.1

package/dist/commands/integration/create.js

@@ -0,0 +1,298 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+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 { resolveOwnerId } from '../../lib/owner-helpers.js';
+import { isInteractive } from '../../lib/stdin.js';
+function formatCreatedIntegration(integration) {
+    console.log(chalk.green('Integration created 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 createIntegrationCreateCommand() {
+    const cmd = new Command('create');
+    cmd
+        .description('Create a new integration')
+        .argument('<name>', 'Integration name')
+        .option('--description <text>', 'What this integration does')
+        .option('--base-url <url>', 'Base URL for all API requests')
+        .option('--owner <account>', 'Owner account name or ID (default: current user)')
+        .option('--public', 'Make this integration visible to all users')
+        .option('--auth-scheme <scheme>', 'Authentication scheme: api-key or oauth')
+        .option('--header-template <template>', 'Header template for API Key auth (default: "X-API-Key: {token}")')
+        .option('--install-url <url>', 'OAuth authorization endpoint')
+        .option('--token-url <url>', 'OAuth token exchange endpoint')
+        .option('--client-id <id>', 'OAuth client ID')
+        .option('--client-secret <secret>', 'OAuth client secret')
+        .option('--scopes <scopes>', 'Comma-separated OAuth scopes')
+        .option('--token-content-type <type>', 'Content-Type for OAuth token request')
+        .option('--webhook-events <events>', 'Enable webhooks with events as JSON')
+        .action(async (name, 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 interactive = isInteractive();
+            // Resolve owner
+            const owner = await resolveOwnerId({
+                ownerFlag: options.owner,
+                client,
+                interactive,
+            });
+            // Resolve description
+            let description = options.description;
+            if (!description) {
+                if (interactive) {
+                    const answer = await inquirer.prompt([
+                        { type: 'input', name: 'description', message: 'Description:' },
+                    ]);
+                    description = answer.description;
+                }
+            }
+            // Resolve base URL
+            let baseUrl = options.baseUrl;
+            if (!baseUrl) {
+                if (interactive) {
+                    const answer = await inquirer.prompt([
+                        { type: 'input', name: 'baseUrl', message: 'Base URL:' },
+                    ]);
+                    baseUrl = answer.baseUrl;
+                }
+            }
+            // Resolve auth scheme
+            let authScheme = options.authScheme;
+            if (!authScheme) {
+                if (interactive) {
+                    const answer = await inquirer.prompt([
+                        {
+                            type: 'list',
+                            name: 'authScheme',
+                            message: 'Select authentication scheme:',
+                            choices: [
+                                {
+                                    name: 'API Key - Static token sent in request headers',
+                                    value: 'api-key',
+                                },
+                                {
+                                    name: 'OAuth 2.0 - User grants access via authorization flow',
+                                    value: 'oauth',
+                                },
+                            ],
+                        },
+                    ]);
+                    authScheme = answer.authScheme;
+                }
+            }
+            // Validate required fields in non-interactive mode
+            const missing = [];
+            if (!description)
+                missing.push('--description <text>');
+            if (!baseUrl)
+                missing.push('--base-url <url>');
+            if (!authScheme)
+                missing.push('--auth-scheme <scheme>');
+            if (missing.length > 0) {
+                output.error(`Error: The following options are required in non-interactive mode:\n  ${missing.join('\n  ')}`, 'Provide all required options, or run interactively (in a TTY) to be prompted.');
+                process.exit(1);
+            }
+            // Build auth config
+            let authConfig;
+            const normalizedScheme = authScheme.toLowerCase();
+            if (normalizedScheme === 'api-key') {
+                let headerTemplate = options.headerTemplate || 'X-API-Key: {token}';
+                if (interactive && !options.headerTemplate) {
+                    const answer = await inquirer.prompt([
+                        {
+                            type: 'input',
+                            name: 'headerTemplate',
+                            message: 'Header template:',
+                            default: 'X-API-Key: {token}',
+                        },
+                    ]);
+                    headerTemplate = answer.headerTemplate;
+                }
+                if (!headerTemplate.includes('{token}')) {
+                    output.error('Error: --header-template must contain {token} placeholder');
+                    process.exit(1);
+                }
+                authConfig = {
+                    auth_scheme: 'API_KEY',
+                    token_header_template: headerTemplate,
+                };
+            }
+            else if (normalizedScheme === 'oauth') {
+                let installUrl = options.installUrl;
+                let tokenUrl = options.tokenUrl;
+                let clientId = options.clientId;
+                let clientSecret = options.clientSecret;
+                if (interactive) {
+                    if (!installUrl) {
+                        const a = await inquirer.prompt([
+                            { type: 'input', name: 'val', message: 'Install URL:' },
+                        ]);
+                        installUrl = a.val;
+                    }
+                    if (!tokenUrl) {
+                        const a = await inquirer.prompt([
+                            { type: 'input', name: 'val', message: 'Token URL:' },
+                        ]);
+                        tokenUrl = a.val;
+                    }
+                    if (!clientId) {
+                        const a = await inquirer.prompt([
+                            { type: 'input', name: 'val', message: 'Client ID:' },
+                        ]);
+                        clientId = a.val;
+                    }
+                    if (!clientSecret) {
+                        const a = await inquirer.prompt([
+                            {
+                                type: 'password',
+                                name: 'val',
+                                message: 'Client Secret:',
+                            },
+                        ]);
+                        clientSecret = a.val;
+                    }
+                }
+                const oauthMissing = [];
+                if (!installUrl)
+                    oauthMissing.push('--install-url');
+                if (!tokenUrl)
+                    oauthMissing.push('--token-url');
+                if (!clientId)
+                    oauthMissing.push('--client-id');
+                if (!clientSecret)
+                    oauthMissing.push('--client-secret');
+                if (oauthMissing.length > 0) {
+                    output.error(`Error: ${oauthMissing.join(', ')}, and --client-secret are required when --auth-scheme is oauth`);
+                    process.exit(1);
+                }
+                authConfig = {
+                    auth_scheme: 'OAUTH',
+                    install_url: installUrl,
+                    token_url: tokenUrl,
+                    client_id: clientId,
+                    client_secret: clientSecret,
+                    token_url_content_type: options.tokenContentType || 'application/x-www-form-urlencoded',
+                };
+                if (options.scopes) {
+                    authConfig.scopes = options.scopes.split(',').map((s) => s.trim());
+                }
+                else if (interactive) {
+                    const answer = await inquirer.prompt([
+                        {
+                            type: 'input',
+                            name: 'scopes',
+                            message: 'Scopes (comma-separated, optional):',
+                        },
+                    ]);
+                    if (answer.scopes) {
+                        authConfig.scopes = answer.scopes
+                            .split(',')
+                            .map((s) => s.trim())
+                            .filter(Boolean);
+                    }
+                }
+            }
+            else {
+                output.error(`Error: Invalid auth scheme '${authScheme}'`, 'Valid schemes: api-key, oauth');
+                process.exit(1);
+            }
+            // Build webhook config
+            let webhookConfig;
+            if (options.webhookEvents) {
+                try {
+                    const events = JSON.parse(options.webhookEvents);
+                    webhookConfig = { events };
+                }
+                catch {
+                    output.error(`Error: Invalid JSON for --webhook-events: ${options.webhookEvents}`);
+                    process.exit(1);
+                }
+            }
+            else if (interactive) {
+                const answer = await inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'configureWebhooks',
+                        message: 'Configure webhooks?',
+                        default: false,
+                    },
+                ]);
+                if (answer.configureWebhooks) {
+                    const eventsAnswer = await inquirer.prompt([
+                        {
+                            type: 'input',
+                            name: 'events',
+                            message: 'Webhook events (JSON):',
+                        },
+                    ]);
+                    if (eventsAnswer.events) {
+                        try {
+                            const events = JSON.parse(eventsAnswer.events);
+                            webhookConfig = { events };
+                        }
+                        catch {
+                            output.error('Error: Invalid JSON for webhook events');
+                            process.exit(1);
+                        }
+                    }
+                }
+            }
+            // Build request body
+            const body = {
+                name,
+                description: description,
+                is_public: options.public || false,
+                protocol_config: {
+                    protocol: 'REST',
+                    base_url: baseUrl,
+                },
+                auth_config: authConfig,
+            };
+            if (webhookConfig) {
+                body.webhook_config = webhookConfig;
+            }
+            const response = await client.post(`/accounts/${owner.name}/integrations`, body);
+            if (getOutputMode() === 'json') {
+                output.data(response);
+            }
+            else {
+                formatCreatedIntegration(response);
+            }
+        }
+        catch (error) {
+            const formattedError = handleAxiosError(error);
+            output.error(`Failed to create integration: ${formattedError.details}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=create.js.map

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

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

package/dist/commands/integration/get.js

@@ -0,0 +1,95 @@
+// 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 formatDate(dateStr) {
+    return new Date(dateStr).toLocaleString('en-US', {
+        month: 'short',
+        day: 'numeric',
+        year: 'numeric',
+        hour: 'numeric',
+        minute: '2-digit',
+    });
+}
+function formatIntegrationDetails(integration) {
+    console.log(chalk.bold(integration.name));
+    console.log();
+    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(`  ${'Created'.padEnd(15)}${formatDate(integration.created_at)}`);
+    console.log(`  ${'Last Updated'.padEnd(15)}${formatDate(integration.updated_at)}`);
+    console.log();
+    console.log(chalk.bold('Protocol'));
+    console.log(`  ${'Type'.padEnd(15)}${integration.protocol_config.protocol}`);
+    console.log(`  ${'Base URL'.padEnd(15)}${integration.protocol_config.base_url}`);
+    console.log();
+    console.log(chalk.bold('Authentication'));
+    const scheme = integration.auth_config.auth_scheme === 'API_KEY' ? 'API Key' : 'OAuth 2.0';
+    console.log(`  ${'Scheme'.padEnd(15)}${scheme}`);
+    if (integration.auth_config.token_header_template) {
+        console.log(`  ${'Header'.padEnd(15)}${integration.auth_config.token_header_template}`);
+    }
+    if (integration.auth_config.install_url) {
+        console.log(`  ${'Install URL'.padEnd(15)}${integration.auth_config.install_url}`);
+    }
+    if (integration.auth_config.token_url) {
+        console.log(`  ${'Token URL'.padEnd(15)}${integration.auth_config.token_url}`);
+    }
+    console.log();
+    if (integration.webhook_config) {
+        console.log(`${'Webhooks'.padEnd(17)}${integration.webhook_config.enabled ? 'Enabled' : 'Disabled'}`);
+        if (integration.webhook_config.events?.length) {
+            console.log(`  ${'Events'.padEnd(15)}${integration.webhook_config.events.join(', ')}`);
+        }
+    }
+    else {
+        console.log(`${'Webhooks'.padEnd(17)}${chalk.dim('Not configured')}`);
+    }
+    console.log();
+    console.log(chalk.bold('Latest Published Version'));
+    if (integration.latest_published_version) {
+        const v = integration.latest_published_version;
+        console.log(`  ${'Version'.padEnd(15)}${v.version_number}`);
+        console.log(`  ${'Published'.padEnd(15)}${formatDate(v.published_at)}`);
+    }
+    else {
+        console.log(`  ${chalk.dim('None')}`);
+    }
+}
+export function createIntegrationGetCommand() {
+    const cmd = new Command('get');
+    cmd
+        .description('Get integration details')
+        .argument('<id_or_name>', 'Integration ID or name (e.g., owner~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.get(`/integrations/${identifier}`);
+            if (getOutputMode() === 'json') {
+                output.data(response);
+            }
+            else {
+                formatIntegrationDetails(response);
+            }
+        }
+        catch (error) {
+            const formattedError = handleAxiosError(error);
+            output.error(`Failed to get integration: ${formattedError.details}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=get.js.map

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

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

package/dist/commands/integration/list.js

@@ -0,0 +1,61 @@
+// 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, formatIntegrationTable } from '../../lib/output.js';
+const SORT_MAP = {
+    updated: 'updated_at',
+    newest: 'created_at',
+    name: 'name',
+};
+export function createIntegrationListCommand() {
+    const cmd = new Command('list');
+    cmd
+        .description('List integrations')
+        .option('--search <query>', 'Search integrations by name or description')
+        .option('--sort <field>', 'Sort by: updated, newest, name (default: updated)', 'updated')
+        .option('--published', 'Only show integrations with at least one published version')
+        .option('--limit <number>', 'Number of results to return', '20')
+        .option('--offset <number>', 'Offset for pagination', '0')
+        .action(async (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);
+            if (options.search) {
+                params.append('search', options.search);
+            }
+            if (options.published) {
+                params.append('published_only', 'true');
+            }
+            const sortField = SORT_MAP[options.sort];
+            if (sortField) {
+                params.append('sort_by', sortField);
+            }
+            const response = await client.get(`/integrations?${params.toString()}`);
+            if (getOutputMode() === 'json') {
+                output.data(response);
+            }
+            else {
+                formatIntegrationTable(response.items, response.pagination);
+            }
+        }
+        catch (error) {
+            const formattedError = handleAxiosError(error);
+            output.error(`Failed to list integrations: ${formattedError.details}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=list.js.map

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

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

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