@guildai/cli 0.11.0 → 0.12.0

package/dist/commands/agent/init.js

@@ -1,403 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-import { Command } from 'commander';
-import { GuildAPIClient } from '../../lib/api-client.js';
-import { handleAxiosError, ErrorCodes } from '../../lib/errors.js';
-import { createSteps, createSpinner, format } from '../../lib/progress.js';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as readline from 'readline';
-import { getAuthenticatedUrl } from '../../lib/auth.js';
-import { runGit, GitError, formatGitError, installPrePushHook } from '../../lib/git.js';
-import { resolveOwnerId } from '../../lib/owner-helpers.js';
-import { isInteractive } from '../../lib/stdin.js';
-const TEMPLATE_CHOICES = [
-    {
-        name: 'LLM - Simple language model agent (recommended)',
-        value: 'LLM',
-        short: 'LLM',
-    },
-    {
-        name: 'Auto-managed state - Agent with automatic state management',
-        value: 'AUTO_MANAGED_STATE',
-        short: 'Auto-managed state',
-    },
-    {
-        name: 'Blank - Start from scratch',
-        value: 'BLANK',
-        short: 'Blank',
-    },
-];
-function slugify(text) {
-    return text
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '');
-}
-const NAME_RULES = 'Lowercase letters, digits, hyphens, and underscores only (1-100 characters)';
-function isValidAgentName(name) {
-    return name.length >= 1 && name.length <= 100 && /^[a-z0-9\-_.]+$/.test(name);
-}
-async function promptForName(defaultName) {
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    const ask = () => new Promise((resolve) => {
-        rl.question(`Agent name [${defaultName}]: `, (answer) => {
-            const trimmed = answer.trim();
-            const name = trimmed || defaultName;
-            if (!isValidAgentName(name)) {
-                console.error(`Invalid name "${name}": ${NAME_RULES}`);
-                resolve(ask());
-            }
-            else {
-                rl.close();
-                resolve(name);
-            }
-        });
-    });
-    return ask();
-}
-async function confirmCreation(ownerName, agentName) {
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    return new Promise((resolve) => {
-        rl.question(`\nYou are about to create agent "${ownerName}~${agentName}".\n` +
-            'Warning: Owner and name cannot be changed after creation, and agents cannot be deleted.\n\n' +
-            'Continue? [y/N] ', (answer) => {
-            rl.close();
-            resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
-        });
-    });
-}
-async function promptForTemplate() {
-    const { default: inquirer } = await import('inquirer');
-    const { template } = await inquirer.prompt([
-        {
-            type: 'list',
-            name: 'template',
-            message: 'Select agent template:',
-            choices: TEMPLATE_CHOICES,
-            default: 'LLM',
-        },
-    ]);
-    return template;
-}
-export function createAgentInitCommand() {
-    const cmd = new Command('init');
-    cmd
-        .description('Initialize a directory as a Guild agent')
-        .option('--name <name>', 'Agent name')
-        .option('--template <template>', 'Agent template (LLM, AUTO_MANAGED_STATE, BLANK)')
-        .option('--fork <agent-id>', 'Fork from existing agent')
-        .option('--owner <owner>', 'Owner (name or ID)')
-        .option('--directory <path>', 'Directory to initialize (default: ./<name>, created if needed)')
-        .option('--force', 'Overwrite existing guild.json', false)
-        .action(async (options) => {
-        // Get agent name first (needed to determine default directory)
-        let agentName = options.name;
-        if (!agentName) {
-            if (isInteractive()) {
-                const dirName = path.basename(process.cwd());
-                const defaultName = slugify(dirName);
-                agentName = await promptForName(defaultName);
-                if (!agentName) {
-                    console.error('Error: Agent name cannot be empty');
-                    process.exit(1);
-                }
-            }
-            else {
-                console.error('Error: Agent name is required');
-                console.error('');
-                console.error('Provide a name:');
-                console.error('  guild agent init --name my-agent');
-                console.error('');
-                console.error('Or run interactively to be prompted for a name.');
-                process.exit(1);
-            }
-        }
-        // Resolve target directory: --directory overrides, otherwise ./<name>
-        const targetDir = options.directory
-            ? path.resolve(process.cwd(), options.directory)
-            : path.resolve(process.cwd(), agentName);
-        // Create directory if it doesn't exist
-        await fs.mkdir(targetDir, { recursive: true });
-        const guildJsonPath = path.join(targetDir, 'guild.json');
-        try {
-            // Check if already initialized
-            const guildJsonExists = await fs
-                .access(guildJsonPath)
-                .then(() => true)
-                .catch(() => false);
-            if (guildJsonExists && !options.force) {
-                const existingConfig = JSON.parse(await fs.readFile(guildJsonPath, 'utf-8'));
-                console.error('Error: Directory already initialized as Guild agent');
-                console.error('');
-                console.error(`guild.json already exists with agent_id: ${existingConfig.agent_id}`);
-                console.error('');
-                console.error('To reinitialize, use: guild agent init --force');
-                process.exit(1);
-            }
-            // Validate name (catches --name flag and non-interactive paths)
-            if (!isValidAgentName(agentName)) {
-                console.error(`Error: Invalid agent name "${agentName}"`);
-                console.error('');
-                console.error(`Agent names must use ${NAME_RULES}`);
-                console.error('');
-                console.error('Examples: my-agent, my_agent');
-                process.exit(1);
-            }
-            // Determine template: use --template option, prompt if interactive, or error
-            let template = options.template;
-            if (!template) {
-                if (isInteractive()) {
-                    template = await promptForTemplate();
-                }
-                else {
-                    console.error('Error: --template is required in non-interactive mode');
-                    console.error('');
-                    console.error('Provide a template:');
-                    console.error('  guild agent init --name my-agent --template LLM');
-                    console.error('');
-                    console.error('Available templates:');
-                    console.error('  • LLM - Simple language model agent (recommended)');
-                    console.error('  • AUTO_MANAGED_STATE - Agent with automatic state management');
-                    console.error('  • BLANK - Start from scratch');
-                    process.exit(1);
-                }
-            }
-            // Normalize template to uppercase for case-insensitive matching
-            template = template.toUpperCase();
-            // Validate template
-            const validTemplates = [
-                'LLM',
-                'AUTO_MANAGED_STATE',
-                'BLANK',
-            ];
-            if (!validTemplates.includes(template)) {
-                console.error(`Error: Invalid template '${template}'`);
-                console.error('');
-                console.error('Valid templates:');
-                console.error('  • LLM');
-                console.error('  • AUTO_MANAGED_STATE');
-                console.error('  • BLANK');
-                process.exit(1);
-            }
-            // Create progress tracker for initialization steps
-            const stepNames = [
-                'Create agent in backend',
-                'Initialize git repository',
-                'Configure git remote',
-                'Wait for backend initialization',
-                'Pull scaffolding from remote',
-                'Create guild.json',
-            ];
-            const steps = createSteps(stepNames);
-            steps.start();
-            // Step 1: Create agent in backend
-            const client = new GuildAPIClient();
-            // Resolve owner
-            const owner = await resolveOwnerId({
-                ownerFlag: options.owner,
-                client,
-                interactive: isInteractive(),
-                requireExplicitOwner: true,
-            });
-            if (isInteractive()) {
-                const confirmed = await confirmCreation(owner.name, agentName);
-                if (!confirmed) {
-                    console.log('Cancelled.');
-                    process.exit(0);
-                }
-            }
-            const agent = await client.post('/agents', {
-                name: agentName,
-                description: `Agent created via CLI`,
-                is_public: false,
-                template,
-                owner_id: owner.id,
-            });
-            steps.succeed('Create agent in backend');
-            format.detail(`Agent: ${agent.name} (${agent.id})`);
-            format.detail(`Owner: ${owner.name}`);
-            // Step 2: Initialize git repository if needed
-            const gitDir = path.join(targetDir, '.git');
-            const gitExists = await fs
-                .access(gitDir)
-                .then(() => true)
-                .catch(() => false);
-            if (!gitExists) {
-                await runGit(['init', '-b', 'main'], { cwd: targetDir });
-                steps.succeed('Initialize git repository');
-            }
-            else {
-                steps.succeed('Initialize git repository');
-                format.detail('Already initialized');
-            }
-            // Step 3: Configure git remote
-            try {
-                // Check if remote 'origin' exists
-                await runGit(['remote', 'get-url', 'origin'], { cwd: targetDir });
-                // Remote exists, update it
-                await runGit(['remote', 'set-url', 'origin', agent.git_url], {
-                    cwd: targetDir,
-                });
-            }
-            catch {
-                // Remote doesn't exist, add it
-                await runGit(['remote', 'add', 'origin', agent.git_url], {
-                    cwd: targetDir,
-                });
-            }
-            steps.succeed('Configure git remote');
-            format.detail(`Remote: ${agent.git_url}`);
-            // Step 2: Wait for backend to complete initialization
-            // Backend pushes scaffolding files in a background task and sets status to READY
-            const spinner = createSpinner('Waiting for backend initialization...');
-            spinner.start();
-            const maxAttempts = 60; // 60 seconds max wait for backend initialization
-            const delayMs = 1000;
-            let agentReady = false;
-            for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-                await new Promise((resolve) => setTimeout(resolve, delayMs));
-                try {
-                    // Poll agent status
-                    const updatedAgent = await client.get(`/agents/${agent.id}`);
-                    if (updatedAgent.status === 'READY') {
-                        agentReady = true;
-                        spinner.succeed('Backend initialization complete');
-                        steps.succeed('Wait for backend initialization');
-                        break;
-                    }
-                    // Update spinner with progress
-                    spinner.text = `Waiting for backend initialization... (${attempt}/${maxAttempts})`;
-                }
-                catch {
-                    // If we can't fetch the agent, continue polling
-                    if (attempt === maxAttempts) {
-                        spinner.warn('Could not verify initialization status');
-                        steps.warn('Wait for backend initialization', 'Status unknown');
-                    }
-                }
-            }
-            if (!agentReady) {
-                spinner.fail('Backend initialization timed out');
-                steps.fail('Wait for backend initialization');
-                console.error('');
-                console.error('The backend is taking longer than expected to initialize the agent.');
-                console.error('This usually means the GitHub repository creation is delayed.');
-                console.error('');
-                console.error('You can check the status later with:');
-                console.error(`  guild agent get ${agent.id}`);
-                console.error('');
-                console.error('Or wait and try pulling the scaffolding manually:');
-                console.error(`  cd ${targetDir}`);
-                console.error('  git pull origin main');
-                process.exit(1);
-            }
-            // Step 5: Pull scaffolding from remote
-            // Retry pull with short delays since GitHub may need a moment after API push
-            const pullMaxAttempts = 15;
-            const pullDelayMs = 1000; // 1 second between attempts
-            // Get authenticated URL for git pull
-            const authenticatedGitUrl = await getAuthenticatedUrl(agent.git_url);
-            if (!authenticatedGitUrl) {
-                console.error('Error: Not authenticated. Run: guild auth login');
-                process.exit(1);
-            }
-            for (let attempt = 1; attempt <= pullMaxAttempts; attempt++) {
-                try {
-                    await runGit(['pull', authenticatedGitUrl, 'main'], { cwd: targetDir });
-                    steps.succeed('Pull scaffolding from remote');
-                    break;
-                }
-                catch (error) {
-                    if (attempt < pullMaxAttempts) {
-                        // Short, consistent delay between retries (total max wait: 15s)
-                        await new Promise((resolve) => setTimeout(resolve, pullDelayMs));
-                    }
-                    else {
-                        // Final attempt failed - log error for debugging
-                        const errMsg = error instanceof GitError
-                            ? error.stderr || error.stdout
-                            : error instanceof Error
-                                ? error.message
-                                : String(error);
-                        steps.warn('Pull scaffolding from remote', 'Could not pull from remote');
-                        format.detail(`Git pull error: ${errMsg}`);
-                        format.detail('Backend may still be initializing the repository');
-                    }
-                }
-            }
-            // Step 6: Create guild.json
-            const guildConfig = {
-                agent_id: agent.id,
-                name: agentName,
-            };
-            await fs.writeFile(guildJsonPath, JSON.stringify(guildConfig, null, 2) + '\n', 'utf-8');
-            steps.succeed('Create guild.json');
-            // Add guild.json and .guild/cache/ to .gitignore if not already present
-            const gitignorePath = path.join(targetDir, '.gitignore');
-            try {
-                const gitignoreContent = await fs.readFile(gitignorePath, 'utf-8');
-                const existingLines = gitignoreContent.split('\n').map((l) => l.trim());
-                const lines = [];
-                if (!existingLines.includes('guild.json')) {
-                    lines.push('guild.json');
-                }
-                if (!existingLines.includes('.guild/cache/')) {
-                    lines.push('.guild/cache/');
-                }
-                if (lines.length > 0) {
-                    const prefix = gitignoreContent.endsWith('\n') ? '' : '\n';
-                    await fs.appendFile(gitignorePath, prefix + lines.join('\n') + '\n');
-                }
-            }
-            catch {
-                // .gitignore doesn't exist (backend should have created it), create it
-                await fs.writeFile(gitignorePath, 'guild.json\n.guild/cache/\n');
-            }
-            // Install pre-push hook to block direct git push
-            await installPrePushHook(targetDir);
-            // Complete progress tracking
-            steps.complete('Agent initialized successfully');
-            // Display next steps
-            format.section('Next steps:');
-            format.detail(`1. cd ${targetDir}`);
-            format.detail('2. Edit agent.ts to implement your agent logic');
-            format.detail('3. git add . && git commit -m "Initial implementation"');
-            format.detail("4. Run 'guild agent save' to push and create a version");
-            format.detail(`5. Run 'guild agent test' to test your agent`);
-            format.detail('');
-            format.detail(`Tip: Using a coding agent? Run 'guild setup' to install skills for Claude Code, Codex, etc.`);
-        }
-        catch (error) {
-            if (error instanceof GitError) {
-                console.error('Error: Git operation failed');
-                console.error('');
-                console.error(formatGitError(error));
-                process.exit(1);
-            }
-            const formattedError = handleAxiosError(error);
-            if (formattedError.code === ErrorCodes.AUTH_REQUIRED) {
-                console.error('Not authenticated. Please log in first.');
-                console.error('');
-                console.error('Run: guild auth login');
-                process.exit(1);
-            }
-            if (formattedError.code === ErrorCodes.CONN_REFUSED) {
-                console.error('Cannot connect to Guild servers.');
-                console.error('');
-                console.error('Please check your connection and try again.');
-                process.exit(1);
-            }
-            console.error(`Failed to initialize agent: ${formattedError.details}`);
-            process.exit(1);
-        }
-    });
-    return cmd;
-}
-//# sourceMappingURL=init.js.map

package/dist/commands/agent/list.js

@@ -1,110 +0,0 @@
-// 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, ErrorCodes } from '../../lib/errors.js';
-import { isMachineReadable } from '../../lib/output-mode.js';
-import { createOutputWriter, formatAgentTable } from '../../lib/output.js';
-import { DEFAULT_PAGE_LIMIT } from '../../lib/api-types.js';
-const SORT_MAP = {
-    updated: 'updated_at',
-    newest: 'created_at',
-    name: 'name',
-    popular: 'cached_likes_count',
-};
-export function createAgentListCommand() {
-    const cmd = new Command('list');
-    cmd
-        .description('List agents')
-        .option('--search <query>', 'Search agents by name or description')
-        .option('--sort <field>', 'Sort by: name, updated, newest, popular (default: name)', 'name')
-        .option('--published', 'Only show published agents')
-        .option('--archived', 'Show only archived agents')
-        .option('--all', 'Show all agents including archived')
-        .option('--owner <name>', 'Filter by owner (user or org name). Without this flag, lists your own agents')
-        .option('--workspace <id>', 'Filter agents by workspace ID or name')
-        .option('--limit <number>', `Number of results to return (default: ${DEFAULT_PAGE_LIMIT})`, String(DEFAULT_PAGE_LIMIT))
-        .option('--offset <number>', 'Offset for pagination (default: 0)', '0')
-        .action(async (options) => {
-        const output = createOutputWriter();
-        if (options.archived && options.all) {
-            output.error('--archived and --all are mutually exclusive', 'Use --archived to show only archived agents, or --all to show all agents including archived');
-            process.exit(1);
-        }
-        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);
-            }
-            // Determine the right endpoint:
-            // - --workspace → GET /agents?for_workspace=... (global, workspace-scoped)
-            // - --owner → GET /users/{owner}/agents or /organizations/{owner}/agents
-            // - default → GET /users/{me}/agents (same as web)
-            let endpoint;
-            const showArchived = options.all || options.archived;
-            if (options.workspace) {
-                // Workspace filter uses the global endpoint
-                params.append('for_workspace', options.workspace);
-                endpoint = `/agents?${params.toString()}`;
-            }
-            else {
-                // Use scoped endpoint (matches web frontend pattern)
-                if (options.archived) {
-                    params.append('include_archived', 'true');
-                }
-                else if (options.all) {
-                    params.append('include_archived', 'true');
-                }
-                const ownerName = options.owner ?? (await client.get('/me')).name;
-                endpoint = `/users/${encodeURIComponent(ownerName)}/agents?${params.toString()}`;
-            }
-            const response = await client.get(endpoint);
-            // When --archived is used, filter to only archived agents client-side
-            // (the backend only supports include_archived, not archived_only)
-            if (options.archived) {
-                response.items = response.items.filter((a) => a.is_archived);
-            }
-            if (isMachineReadable()) {
-                output.data(response);
-            }
-            else {
-                formatAgentTable(response.items, response.pagination, showArchived);
-            }
-        }
-        catch (error) {
-            const formattedError = handleAxiosError(error);
-            if (formattedError.code === ErrorCodes.NOT_FOUND) {
-                if (options.workspace) {
-                    output.error('Workspace not found');
-                }
-                else if (options.owner) {
-                    output.error(`Owner not found: ${options.owner}`);
-                }
-                else {
-                    output.error('Not found');
-                }
-                process.exit(1);
-            }
-            output.error(`Failed to list agents: ${formattedError.details}`);
-            process.exit(1);
-        }
-    });
-    return cmd;
-}
-//# sourceMappingURL=list.js.map

package/dist/commands/agent/logs.js

@@ -1,62 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-import { Command } from 'commander';
-import { GuildAPIClient } from '../../lib/api-client.js';
-import { getGuildcoreUrl } from '../../lib/config.js';
-import { handleAxiosError, ErrorCodes } from '../../lib/errors.js';
-import { getAgentId, resolveAgentRef } from '../../lib/agent-helpers.js';
-import { isMachineReadable } from '../../lib/output-mode.js';
-import { createOutputWriter, formatValidationLogs } from '../../lib/output.js';
-export function createAgentLogsCommand() {
-    const cmd = new Command('logs');
-    cmd
-        .description('Show build/validation logs for an agent version')
-        .argument('[identifier]', 'Agent ID or full name (e.g., "owner~agent-name")')
-        .argument('[version-id]', 'ID of the version to show logs for (uses latest if omitted)')
-        .action(async (agentIdArg, versionIdArg) => {
-        const output = createOutputWriter();
-        // Get agent ID from argument or guild.json
-        const { agentId } = await getAgentId(agentIdArg);
-        const baseUrl = getGuildcoreUrl();
-        const client = new GuildAPIClient({ baseUrl });
-        try {
-            const resolvedId = await resolveAgentRef(client, agentId);
-            let versionId = versionIdArg;
-            // If no version ID provided, get the latest version
-            if (!versionId) {
-                const versions = await client.get(`/agents/${resolvedId}/versions?limit=1&offset=0`);
-                if (!versions.items || versions.items.length === 0) {
-                    output.error('No versions found for this agent.', `The agent may still be initializing. Check status:\n  guild agent get ${agentId}`);
-                    process.exit(1);
-                }
-                versionId = versions.items[0].id;
-            }
-            // Fetch validation steps for the version
-            const stepsResponse = await client.get(`/versions/${versionId}/validation/steps`);
-            if (isMachineReadable()) {
-                output.data(stepsResponse);
-            }
-            else {
-                formatValidationLogs(stepsResponse.steps);
-            }
-        }
-        catch (error) {
-            const formattedError = handleAxiosError(error);
-            if (formattedError.code === ErrorCodes.AUTH_REQUIRED) {
-                output.error('Not authenticated.', 'Please authenticate first:\n  guild auth login');
-            }
-            else if (formattedError.code === ErrorCodes.CONN_REFUSED) {
-                output.error('Cannot connect to Guild servers');
-            }
-            else if (formattedError.code === ErrorCodes.NOT_FOUND) {
-                output.error('Agent or version not found', `Check the agent and version IDs:\n  guild agent list\n  guild agent versions ${agentId}`);
-            }
-            else {
-                output.error(`Failed to retrieve logs: ${formattedError.details}`);
-            }
-            process.exit(1);
-        }
-    });
-    return cmd;
-}
-//# sourceMappingURL=logs.js.map

package/dist/commands/agent/owners.js

@@ -1,74 +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 { handleAxiosError, ErrorCodes } from '../../lib/errors.js';
-import { isMachineReadable } from '../../lib/output-mode.js';
-import { createOutputWriter } from '../../lib/output.js';
-import { loadGlobalConfig } from '../../lib/guild-config.js';
-export function createAgentOwnersCommand() {
-    const cmd = new Command('owners');
-    cmd.description('List accounts that can own agents').action(async () => {
-        const output = createOutputWriter();
-        try {
-            const mode = isMachineReadable();
-            const client = new GuildAPIClient();
-            const [me, orgs, globalConfig] = await Promise.all([
-                client.get('/me'),
-                client.fetchAll('/me/organizations'),
-                loadGlobalConfig(),
-            ]);
-            const defaultOwnerId = globalConfig?.default_owner;
-            const owners = [
-                {
-                    id: me.id,
-                    name: me.name,
-                    type: 'user',
-                    is_default: defaultOwnerId === me.id,
-                },
-                ...orgs.map((org) => ({
-                    id: org.id,
-                    name: org.name,
-                    type: 'organization',
-                    is_default: defaultOwnerId === org.id,
-                })),
-            ];
-            if (mode) {
-                output.data({ owners });
-                return;
-            }
-            // Table display
-            console.log('');
-            console.log(`${chalk.dim('TYPE')}            ${chalk.dim('NAME')}                     ${chalk.dim('ID')}`);
-            console.log(chalk.dim('─'.repeat(72)));
-            for (const owner of owners) {
-                const typeLabel = owner.type === 'user' ? 'user' : 'org';
-                const typePadded = typeLabel.padEnd(15);
-                const defaultLabel = owner.is_default ? chalk.cyan(' (default)') : '';
-                const namePadded = (owner.name + (owner.is_default ? '' : '')).padEnd(25);
-                console.log(`${typePadded} ${namePadded}${defaultLabel ? defaultLabel + '  ' : ''}${chalk.dim(owner.id)}`);
-            }
-            console.log('');
-            if (!defaultOwnerId) {
-                console.log(chalk.dim('No default owner set. Run: guild config set default_owner <id>'));
-                console.log('');
-            }
-        }
-        catch (error) {
-            const formattedError = handleAxiosError(error);
-            if (formattedError.code === ErrorCodes.AUTH_REQUIRED) {
-                output.error('Not authenticated. Please log in first.', 'Run: guild auth login');
-                process.exit(1);
-            }
-            if (formattedError.code === ErrorCodes.CONN_REFUSED) {
-                output.error('Cannot connect to Guild servers.', 'Please check your connection and try again.');
-                process.exit(1);
-            }
-            output.error(`Failed to list owners: ${formattedError.details}`);
-            process.exit(1);
-        }
-    });
-    return cmd;
-}
-//# sourceMappingURL=owners.js.map