@guildai/cli 0.11.0 → 0.12.0

package/dist/commands/doctor.js

@@ -1,233 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-import { Command } from 'commander';
-import chalk from 'chalk';
-import axios from 'axios';
-import { getAuthToken } from '../lib/auth.js';
-import { getGuildcoreUrl } from '../lib/config.js';
-import { loadGlobalConfig, isAgentDirectory, getGlobalConfigPath, loadLocalConfig, } from '../lib/guild-config.js';
-import { isMachineReadable } from '../lib/output-mode.js';
-import { createOutputWriter } from '../lib/output.js';
-async function checkAuth() {
-    const token = await getAuthToken();
-    if (token) {
-        return { name: 'Authentication', status: 'pass', message: 'Logged in' };
-    }
-    return {
-        name: 'Authentication',
-        status: 'fail',
-        message: 'Not logged in',
-        suggestion: 'Run: guild auth login',
-    };
-}
-async function checkServer() {
-    const url = getGuildcoreUrl();
-    const token = await getAuthToken();
-    const headers = {};
-    if (token) {
-        headers['Authorization'] = `Bearer ${token}`;
-    }
-    const start = Date.now();
-    try {
-        const response = await axios.get(`${url}/me`, {
-            timeout: 10000,
-            headers,
-            validateStatus: () => true,
-        });
-        const elapsed = Date.now() - start;
-        if (response.status >= 200 && response.status < 300) {
-            return {
-                name: 'Server',
-                status: 'pass',
-                message: `Connected to ${url} (${elapsed}ms)`,
-            };
-        }
-        if (response.status === 401) {
-            // Server is up but auth failed — still a successful connectivity check.
-            // checkAuth handles the auth failure separately.
-            return {
-                name: 'Server',
-                status: 'pass',
-                message: `Connected to ${url} (${elapsed}ms, auth required)`,
-            };
-        }
-        return {
-            name: 'Server',
-            status: 'pass',
-            message: `Connected to ${url} (${elapsed}ms, HTTP ${response.status})`,
-        };
-    }
-    catch {
-        return {
-            name: 'Server',
-            status: 'fail',
-            message: `Cannot connect to ${url}`,
-            suggestion: 'Check your network connection',
-        };
-    }
-}
-async function checkGlobalConfig() {
-    const config = await loadGlobalConfig();
-    const configPath = getGlobalConfigPath();
-    if (config) {
-        return {
-            name: 'Global config',
-            status: 'pass',
-            message: configPath.replace(process.env.HOME || '', '~'),
-        };
-    }
-    return {
-        name: 'Global config',
-        status: 'fail',
-        message: 'Not found',
-        suggestion: `Expected at ${configPath.replace(process.env.HOME || '', '~')}`,
-    };
-}
-async function checkDefaultWorkspace() {
-    const config = await loadGlobalConfig();
-    if (config?.default_workspace) {
-        const display = config.default_workspace_name || config.default_workspace;
-        return {
-            name: 'Default workspace',
-            status: 'pass',
-            message: display,
-        };
-    }
-    return {
-        name: 'Default workspace',
-        status: 'fail',
-        message: 'Not configured',
-        suggestion: 'Run: guild workspace select',
-    };
-}
-async function checkLocalConfig() {
-    const isAgent = await isAgentDirectory();
-    if (!isAgent) {
-        return {
-            name: 'Local config',
-            status: 'skip',
-            message: 'Not in an agent directory',
-        };
-    }
-    const config = await loadLocalConfig();
-    if (config) {
-        return {
-            name: 'Local config',
-            status: 'pass',
-            message: `Agent: ${config.name || config.agent_id}`,
-        };
-    }
-    return {
-        name: 'Local config',
-        status: 'fail',
-        message: 'guild.json found but could not be parsed',
-        suggestion: 'Check guild.json for valid JSON',
-    };
-}
-async function checkConfigFlags() {
-    const config = await loadGlobalConfig();
-    const flags = ['debug', 'json', 'quiet'];
-    const enabled = flags.filter((f) => config?.[f] === true);
-    if (enabled.length > 0) {
-        return {
-            name: 'Config flags',
-            status: 'pass',
-            message: `Enabled: ${enabled.join(', ')}`,
-        };
-    }
-    return {
-        name: 'Config flags',
-        status: 'skip',
-        message: 'No persistent flags set',
-    };
-}
-async function checkGit() {
-    const isAgent = await isAgentDirectory();
-    if (!isAgent) {
-        return {
-            name: 'Git',
-            status: 'skip',
-            message: 'Not in an agent directory',
-        };
-    }
-    try {
-        const { execa } = await import('execa');
-        await execa('git', ['--version']);
-        // Check for remote
-        const { stdout } = await execa('git', ['remote', '-v'], { reject: false });
-        if (stdout && stdout.includes('origin')) {
-            return { name: 'Git', status: 'pass', message: 'Installed, remote configured' };
-        }
-        return {
-            name: 'Git',
-            status: 'fail',
-            message: 'Installed but no remote configured',
-            suggestion: 'Run: git remote add origin <url>',
-        };
-    }
-    catch {
-        return {
-            name: 'Git',
-            status: 'fail',
-            message: 'Git not found',
-            suggestion: 'Install git: https://git-scm.com',
-        };
-    }
-}
-export function createDoctorCommand() {
-    const cmd = new Command('doctor');
-    cmd.description('Check CLI setup and diagnose issues').action(async () => {
-        const output = createOutputWriter();
-        const jsonMode = isMachineReadable();
-        const checks = [];
-        if (!jsonMode) {
-            output.progress('\nChecking Guild CLI setup...\n');
-        }
-        const runners = [
-            checkAuth,
-            checkServer,
-            checkGlobalConfig,
-            checkDefaultWorkspace,
-            checkConfigFlags,
-            checkLocalConfig,
-            checkGit,
-        ];
-        for (const runner of runners) {
-            const result = await runner();
-            checks.push(result);
-            if (!jsonMode) {
-                const icon = result.status === 'pass'
-                    ? chalk.green('✓')
-                    : result.status === 'fail'
-                        ? chalk.red('✗')
-                        : chalk.dim('-');
-                const nameCol = result.name.padEnd(20);
-                output.progress(`  ${icon} ${chalk.bold(nameCol)} ${result.message}`);
-                if (result.suggestion) {
-                    output.progress(`    ${chalk.dim(result.suggestion)}`);
-                    output.progress('');
-                }
-            }
-        }
-        const passed = checks.filter((c) => c.status === 'pass').length;
-        const failed = checks.filter((c) => c.status === 'fail').length;
-        const skipped = checks.filter((c) => c.status === 'skip').length;
-        if (jsonMode) {
-            output.data({ checks, passed, failed, skipped });
-        }
-        else {
-            output.progress('');
-            const parts = [];
-            if (passed > 0)
-                parts.push(chalk.green(`${passed} passed`));
-            if (failed > 0)
-                parts.push(chalk.red(`${failed} failed`));
-            if (skipped > 0)
-                parts.push(chalk.dim(`${skipped} skipped`));
-            output.progress(parts.join(', '));
-        }
-        process.exit(failed > 0 ? 1 : 0);
-    });
-    return cmd;
-}
-//# sourceMappingURL=doctor.js.map

package/dist/commands/integration/connect.js

@@ -1,76 +0,0 @@
-// 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 { isMachineReadable } from '../../lib/output-mode.js';
-import { createOutputWriter } from '../../lib/output.js';
-import { isInteractive } from '../../lib/stdin.js';
-export function createIntegrationConnectCommand() {
-    const cmd = new Command('connect');
-    cmd
-        .description('Connect credentials to an integration')
-        .argument('<id_or_name>', 'Integration ID (UUID) or name in owner~name format (e.g. myorg~my-integration)')
-        .option('--token <value>', 'API key value (required in non-interactive mode)')
-        .requiredOption('--owner <id_or_name>', 'Account to own the credential — username, org name, or account ID')
-        .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);
-            }
-            if (!options.token && !isInteractive()) {
-                output.error('--token is required in non-interactive mode');
-                process.exit(1);
-            }
-            const client = new GuildAPIClient();
-            const integration = await client.get(`/integrations/${identifier}`);
-            if (!integration.auth_config) {
-                output.error('This integration has no authentication configured.');
-                process.exit(1);
-            }
-            if (integration.auth_config.entity_type !== 'EntIntegrationAuthConfigApiKey') {
-                output.error('OAuth integrations must be connected via the dashboard.');
-                process.exit(1);
-            }
-            let apiKey = options.token;
-            if (!apiKey) {
-                const { default: inquirer } = await import('inquirer');
-                const answer = await inquirer.prompt([
-                    {
-                        type: 'password',
-                        name: 'apiKey',
-                        message: 'API Key:',
-                        validate: (input) => input.length > 0 || 'API key cannot be empty',
-                    },
-                ]);
-                apiKey = answer.apiKey;
-            }
-            const params = new URLSearchParams();
-            params.append('auth_config_id', integration.auth_config.id);
-            params.append('owner_id', options.owner);
-            const credential = await client.post(`/credentials/api-key?${params.toString()}`, { tokens: { token: apiKey } });
-            if (isMachineReadable()) {
-                output.data(credential);
-            }
-            else {
-                console.log(chalk.green('Connected to ') + chalk.bold(integration.name));
-                console.log();
-                console.log(`  ${'Credential ID'.padEnd(15)}${credential.id}`);
-                console.log(`  ${'Integration'.padEnd(15)}${integration.owner.name}~${integration.name}`);
-                console.log(`  ${'Owner'.padEnd(15)}${options.owner}`);
-            }
-        }
-        catch (error) {
-            const formattedError = handleAxiosError(error);
-            output.error(`Failed to connect: ${formattedError.details}`);
-            process.exit(1);
-        }
-    });
-    return cmd;
-}
-//# sourceMappingURL=connect.js.map

package/dist/commands/integration/create.js

@@ -1,298 +0,0 @@
-// 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 { isMachineReadable } 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 && interactive) {
-                const { default: inquirer } = await import('inquirer');
-                const answer = await inquirer.prompt([
-                    { type: 'input', name: 'description', message: 'Description:' },
-                ]);
-                description = answer.description;
-            }
-            // Resolve base URL
-            let baseUrl = options.baseUrl;
-            if (!baseUrl && interactive) {
-                const { default: inquirer } = await import('inquirer');
-                const answer = await inquirer.prompt([
-                    { type: 'input', name: 'baseUrl', message: 'Base URL:' },
-                ]);
-                baseUrl = answer.baseUrl;
-            }
-            // Resolve auth scheme
-            let authScheme = options.authScheme;
-            if (!authScheme && interactive) {
-                const { default: inquirer } = await import('inquirer');
-                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 { default: inquirer } = await import('inquirer');
-                    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) {
-                    const { default: inquirer } = await import('inquirer');
-                    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 { default: inquirer } = await import('inquirer');
-                    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 { default: inquirer } = await import('inquirer');
-                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 (isMachineReadable()) {
-                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