@guildai/cli 0.9.0 → 0.10.0

package/dist/commands/chat.js

@@ -13,12 +13,12 @@ import chalk from 'chalk';
 import { readFileSync } from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { isUnfulfilledAgentInstallRequest, isFilteredTaskName, getTaskDisplayName, getAgentName, } from '../lib/session-events.js';
+import { isUnfulfilledAgentInstallRequest, isFilteredTaskName, getTaskDisplayName, getAgentName, getAgentNotificationText, isDoneResponseStreamEvent, isResponseStreamEvent, isRootTaskEvent, } from '../lib/session-events.js';
 import { printResumeHint, fetchSession, fetchSessionEvents, eventsToDisplayMessages, } from '../lib/session-resume.js';
 import { DEFAULT_EVENT_TYPES, parseEventFilter, shouldShowEvent, } from '../lib/event-filter.js';
 import { fetchEvents, fetchTasks } from '../lib/session-events-fetch.js';
 import { AgentInstallPrompt } from '../components/AgentInstallPrompt.js';
-import { getWorkspaceId } from '../lib/guild-config.js';
+import { getWorkspaceId, getWorkspaceSourceLabel } from '../lib/guild-config.js';
 import { ensureInteractiveStdin } from '../lib/stdin.js';
 import { brand, BRAND_COLOR, code as codeColor, hyperlink } from '../lib/colors.js';
 import { SplashAnimation } from '../components/SplashAnimation.js';
@@ -31,6 +31,28 @@ import { getOutputMode, isQuietMode } from '../lib/output-mode.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // Read version from package.json
 const packageJson = JSON.parse(readFileSync(path.join(__dirname, '../../package.json'), 'utf-8'));
+// ---------------------------------------------------------------------------
+// Workspace error types
+// ---------------------------------------------------------------------------
+/** Thrown when no workspace is configured (no --workspace flag, no config). */
+export class WorkspaceNotConfiguredError extends Error {
+    constructor() {
+        super('No workspace configured.');
+        this.name = 'WorkspaceNotConfiguredError';
+    }
+}
+/** Thrown when the specified workspace ID is not found in the backend. */
+export class WorkspaceNotFoundError extends Error {
+    workspaceId;
+    constructor(workspaceId) {
+        super(`Workspace ${workspaceId} not found.`);
+        this.name = 'WorkspaceNotFoundError';
+        this.workspaceId = workspaceId;
+    }
+}
+/** User-facing error messages for workspace resolution failures. */
+const WORKSPACE_NOT_CONFIGURED_MSG = 'No workspace configured. Pass a --workspace <id_or_name> argument or run guild workspace select';
+const WORKSPACE_NOT_FOUND_MSG = "The workspace doesn't exist.";
 // Configure marked for terminal
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 marked.use(markedTerminal({}, { theme: {} }));
@@ -48,6 +70,48 @@ function fixListItemMarkdown(text) {
     text = text.replace(/(?<![\\w])_([^_]+)_(?![\\w])/g, (_, content) => chalk.italic(content));
     return text;
 }
+function extractMessageText(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith('{') || !trimmed.endsWith('}'))
+        return text;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (typeof parsed === 'object' && parsed !== null && 'message' in parsed) {
+            return typeof parsed.message === 'string' ? parsed.message : text;
+        }
+    }
+    catch {
+        // If parsing fails, use the content as-is.
+    }
+    return text;
+}
+function extractRuntimeDoneText(content) {
+    if (content === null || content === undefined)
+        return null;
+    if (typeof content === 'string')
+        return content.trim() ? content : null;
+    if (typeof content !== 'object' || Array.isArray(content)) {
+        return JSON.stringify(content);
+    }
+    const record = content;
+    if (Object.keys(record).length === 0)
+        return null;
+    if (record.type === 'text') {
+        if (typeof record.text === 'string')
+            return record.text;
+        if (typeof record.data === 'string')
+            return record.data;
+    }
+    if (typeof record.message === 'string')
+        return record.message;
+    // runtime_done content is agent output, not notification content. Preserve
+    // structured outputs rather than trying to render notification-only shapes.
+    return JSON.stringify(content);
+}
+function renderAssistantMessage(text, taskName) {
+    const rendered = fixListItemMarkdown(marked.parse(text));
+    return `${chalk.green('●')} ${chalk.bold(taskName)}\n${rendered.trim()}`;
+}
 /**
  * Output the result of a --once mode session.
  * Handles both JSON and human-readable output formats.
@@ -57,21 +121,29 @@ async function outputOnceResult(sessionId, events, mode) {
         console.log(JSON.stringify({ session_id: sessionId, events }, null, 2));
     }
     else {
-        const agentMessages = events.filter((e) => e.type === 'agent_notification_message');
-        if (agentMessages.length > 0) {
-            let messageContent = agentMessages[agentMessages.length - 1].content.data;
-            const trimmed = messageContent.trim();
-            if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
-                try {
-                    const parsed = JSON.parse(trimmed);
-                    if (typeof parsed === 'object' && parsed !== null && 'message' in parsed) {
-                        messageContent = parsed.message;
-                    }
-                }
-                catch {
-                    // If parsing fails, use content as-is
-                }
+        const finalAgentMessages = events.filter((e) => e.type === 'agent_notification_message' &&
+            isRootTaskEvent(e) &&
+            !isResponseStreamEvent(e));
+        const streamFallbacks = events.filter((e) => e.type === 'agent_notification_message' &&
+            isRootTaskEvent(e) &&
+            isDoneResponseStreamEvent(e));
+        if (finalAgentMessages.length > 0) {
+            const messageContent = extractMessageText(getAgentNotificationText(finalAgentMessages[finalAgentMessages.length - 1]));
+            const rendered = fixListItemMarkdown(await marked(messageContent));
+            console.log(rendered.trim());
+            return;
+        }
+        const runtimeDoneEvents = events.filter((e) => e.type === 'runtime_done' && isRootTaskEvent(e) && e.content);
+        const runtimeDoneWithContent = runtimeDoneEvents[runtimeDoneEvents.length - 1];
+        if (runtimeDoneWithContent?.type === 'runtime_done') {
+            const runtimeDoneText = extractRuntimeDoneText(runtimeDoneWithContent.content);
+            if (runtimeDoneText) {
+                console.log(runtimeDoneText);
+                return;
             }
+        }
+        if (streamFallbacks.length > 0) {
+            const messageContent = extractMessageText(getAgentNotificationText(streamFallbacks[streamFallbacks.length - 1]));
             const rendered = fixListItemMarkdown(await marked(messageContent));
             console.log(rendered.trim());
         }
@@ -214,8 +286,11 @@ export function ChatApp({ initialPrompt, version, workspaceId, versionId, agentN
                     formattedError.code === ErrorCodes.AUTH_TOKEN_INVALID) {
                     format.error('Not authenticated. Run: guild auth login');
                 }
-                else if (details.includes('workspace')) {
-                    format.error('Workspace not found. Run: guild workspace select');
+                else if (error instanceof WorkspaceNotConfiguredError) {
+                    format.error(WORKSPACE_NOT_CONFIGURED_MSG);
+                }
+                else if (error instanceof WorkspaceNotFoundError) {
+                    format.error(WORKSPACE_NOT_FOUND_MSG);
                 }
                 else if (details.includes('agent')) {
                     format.error('Agent not found in workspace.');
@@ -427,6 +502,83 @@ function ChatUIWithConnection({ initialPrompt, version: _version, versionId: _ve
     const isPolling = useRef(false);
     const receivedResponseSinceLastInput = useRef(false);
     const firstMessageNotified = useRef(!!resumeEvents);
+    const responseStreamKeys = useRef(new Map());
+    const responseStreamTimestamps = useRef(new Map());
+    const responseStreamKeysByTask = useRef(new Map());
+    const clearResponseStreamsForTask = (taskId) => {
+        if (!taskId)
+            return;
+        const keys = responseStreamKeysByTask.current.get(taskId);
+        if (!keys?.size)
+            return;
+        for (const [streamId, key] of responseStreamKeys.current.entries()) {
+            if (keys.has(key)) {
+                responseStreamKeys.current.delete(streamId);
+                responseStreamTimestamps.current.delete(streamId);
+            }
+        }
+        responseStreamKeysByTask.current.delete(taskId);
+        setMessages((prev) => prev.filter((message) => !keys.has(message.key)));
+    };
+    const upsertResponseStreamMessage = (event) => {
+        if (!isResponseStreamEvent(event))
+            return;
+        if (!isRootTaskEvent(event))
+            return;
+        const streamId = event.content.stream_id;
+        const taskId = event.task?.id;
+        const existingKey = responseStreamKeys.current.get(streamId);
+        if (event.content.status === 'aborted') {
+            if (existingKey) {
+                responseStreamKeys.current.delete(streamId);
+                responseStreamTimestamps.current.delete(streamId);
+                if (taskId) {
+                    const keys = responseStreamKeysByTask.current.get(taskId);
+                    keys?.delete(existingKey);
+                    if (keys?.size === 0)
+                        responseStreamKeysByTask.current.delete(taskId);
+                }
+                setMessages((prev) => prev.filter((message) => message.key !== existingKey));
+            }
+            return;
+        }
+        const text = event.content.text;
+        if (!text.trim())
+            return;
+        const key = existingKey ?? `response-stream-${streamId}`;
+        responseStreamKeys.current.set(streamId, key);
+        if (taskId) {
+            const keys = responseStreamKeysByTask.current.get(taskId) ?? new Set();
+            keys.add(key);
+            responseStreamKeysByTask.current.set(taskId, keys);
+        }
+        const taskName = agentName || 'assistant';
+        const messageContent = renderAssistantMessage(text, taskName);
+        const timestamp = responseStreamTimestamps.current.get(streamId) ?? new Date().toLocaleTimeString();
+        responseStreamTimestamps.current.set(streamId, timestamp);
+        setMessages((prev) => {
+            const index = prev.findIndex((message) => message.key === key);
+            const message = {
+                key,
+                content: messageContent,
+                type: 'assistant',
+                timestamp,
+            };
+            if (index === -1)
+                return [...prev, message];
+            const next = [...prev];
+            next[index] = message;
+            return next;
+        });
+        if (!firstMessageNotified.current && onFirstMessage) {
+            firstMessageNotified.current = true;
+            onFirstMessage();
+        }
+        if (event.content.status === 'done') {
+            receivedResponseSinceLastInput.current = true;
+            setCurrentOperation('');
+        }
+    };
     // Mark initial prompt as sent (skip for resume — we already have the events)
     useEffect(() => {
         if (!resumeEvents) {
@@ -526,6 +678,7 @@ function ChatUIWithConnection({ initialPrompt, version: _version, versionId: _ve
                         }
                         // Process events that affect the chat UI (task state comes from tasks poll)
                         if (event.type === 'runtime_error') {
+                            clearResponseStreamsForTask(taskInfo?.id);
                             // Always clear the spinner on runtime errors so the UI doesn't get stuck
                             setCurrentOperation('');
                             // Show runtime errors in the chat (gated on --events filter)
@@ -639,32 +792,15 @@ function ChatUIWithConnection({ initialPrompt, version: _version, versionId: _ve
                             }
                         }
                         else if (event.type === 'agent_notification_message') {
-                            let text = typeof event.content === 'string'
-                                ? event.content
-                                : event.content?.data || '';
-                            // Extract message content, handling JSON responses with "message" field
-                            const trimmed = text.trim();
-                            if (trimmed) {
-                                // Check if content looks like JSON object with "message" field
-                                if (trimmed.startsWith('{') && trimmed.endsWith('}')) {
-                                    try {
-                                        const parsed = JSON.parse(trimmed);
-                                        // If JSON has a "message" field, extract it (some agents wrap responses this way)
-                                        if (typeof parsed === 'object' &&
-                                            parsed !== null &&
-                                            'message' in parsed) {
-                                            text = parsed.message;
-                                        }
-                                        // Otherwise use full JSON content as-is (legitimate JSON responses)
-                                    }
-                                    catch {
-                                        // If parsing fails, use the content as-is
-                                    }
-                                }
-                                const rendered = fixListItemMarkdown(marked.parse(text));
-                                // Add attribution with task name
+                            if (isResponseStreamEvent(event)) {
+                                upsertResponseStreamMessage(event);
+                                continue;
+                            }
+                            const text = extractMessageText(getAgentNotificationText(event));
+                            if (text.trim()) {
+                                clearResponseStreamsForTask(taskInfo?.id);
                                 const taskName = agentName || 'assistant';
-                                const messageContent = `${chalk.green('●')} ${chalk.bold(taskName)}\n${rendered.trim()}`;
+                                const messageContent = renderAssistantMessage(text, taskName);
                                 setMessages((prev) => [
                                     ...prev,
                                     {
@@ -684,6 +820,7 @@ function ChatUIWithConnection({ initialPrompt, version: _version, versionId: _ve
                             setCurrentOperation('');
                         }
                         else if (event.type === 'agent_notification_error') {
+                            clearResponseStreamsForTask(taskInfo?.id);
                             // Show error in chat (task status is updated via tasks poll)
                             const errorText = typeof event.content === 'string'
                                 ? event.content
@@ -730,6 +867,7 @@ function ChatUIWithConnection({ initialPrompt, version: _version, versionId: _ve
                                 event.content !== undefined &&
                                 taskInfo &&
                                 'agent' in taskInfo) {
+                                clearResponseStreamsForTask(taskInfo.id);
                                 // One-shot agents may complete with runtime_done without sending
                                 // agent_notification_message. Display the output if we haven't
                                 // already shown a response for this input cycle.
@@ -759,6 +897,7 @@ function ChatUIWithConnection({ initialPrompt, version: _version, versionId: _ve
                             }
                         }
                         else if (event.type === 'interrupted') {
+                            clearResponseStreamsForTask(taskInfo?.id);
                             // Session was interrupted — interrupted sessions are terminal on the backend
                             setMessages((prev) => [
                                 ...prev,
@@ -987,10 +1126,14 @@ export async function createSession(client, workspaceId, initialPrompt, versionI
         const resolved = await getWorkspaceId();
         if (resolved) {
             workspaceId = resolved.workspaceId;
+            const sourceLabel = getWorkspaceSourceLabel(resolved.source);
+            if (sourceLabel) {
+                progress(`Using workspace from ${sourceLabel}`);
+            }
         }
     }
     if (!workspaceId) {
-        throw new Error('No workspace configured. Run: guild workspace select, or pass --workspace <id>');
+        throw new WorkspaceNotConfiguredError();
     }
     progress('Creating session');
     const sessionData = {
@@ -1009,7 +1152,7 @@ export async function createSession(client, workspaceId, initialPrompt, versionI
     catch (error) {
         const err = handleAxiosError(error);
         if (err.code === ErrorCodes.NOT_FOUND) {
-            throw new Error(`Workspace ${workspaceId} not found. Run: guild workspace select`);
+            throw new WorkspaceNotFoundError(workspaceId);
         }
         throw error;
     }
@@ -1045,7 +1188,9 @@ export function createChatCommand() {
             try {
                 await ensureAuthenticated();
                 const client = new GuildAPIClient();
-                const session = await createSession(client, options.workspace, initialPrompt, options.agent);
+                const session = await createSession(client, options.workspace, initialPrompt, options.agent, (status) => {
+                    spinner.text = status;
+                });
                 spinner.succeed('Connected');
                 if (session.session_url) {
                     const sessionLink = hyperlink(session.id, session.session_url);
@@ -1084,12 +1229,18 @@ export function createChatCommand() {
                     else {
                         inactivityCounter++;
                     }
-                    const isRootTask = (e) => !e.task?.parent_task;
-                    const hasRootTaskDone = allEvents.some((e) => e.type === 'runtime_done' && isRootTask(e));
-                    const hasAgentMessage = allEvents.some((e) => e.type === 'agent_notification_message' && isRootTask(e));
-                    const hasRootTaskError = allEvents.some((e) => e.type === 'runtime_error' && isRootTask(e));
+                    // Check if we got a completion response from the root agent.
+                    // Stream done events are only a rendering fallback; wait for the
+                    // final root message or runtime completion so child drafts cannot
+                    // terminate --once early.
+                    const hasRootTaskDone = allEvents.some((e) => e.type === 'runtime_done' && isRootTaskEvent(e));
+                    const hasAgentMessage = allEvents.some((e) => e.type === 'agent_notification_message' &&
+                        isRootTaskEvent(e) &&
+                        !isResponseStreamEvent(e));
+                    const hasRootTaskError = allEvents.some((e) => e.type === 'runtime_error' && isRootTaskEvent(e));
                     // Check for a ui_prompt request... that ends the game.
                     const hasUIPromptMessage = allEvents.some((e) => e.type === 'agent_notification_message' &&
+                        !isResponseStreamEvent(e) &&
                         e.task?.tool_name === 'ui_prompt');
                     if (hasRootTaskError) {
                         debug('Found error event from root agent, exiting --once mode');
@@ -1130,6 +1281,14 @@ export function createChatCommand() {
             catch (error) {
                 spinner.fail('Connection failed');
                 console.error('');
+                if (error instanceof WorkspaceNotConfiguredError) {
+                    format.error(WORKSPACE_NOT_CONFIGURED_MSG);
+                    process.exit(1);
+                }
+                if (error instanceof WorkspaceNotFoundError) {
+                    format.error(WORKSPACE_NOT_FOUND_MSG);
+                    process.exit(1);
+                }
                 const formattedError = handleAxiosError(error);
                 console.error(`Error: ${formattedError.error}`);
                 console.error(formattedError.details);
@@ -1177,4 +1336,10 @@ export function createChatCommand() {
     });
     return cmd;
 }
+// Thin wrapper for lazy-loading from index.ts (avoids importing React at startup)
+export async function handleChatAction(_promptArgs, _options) {
+    const cmd = createChatCommand();
+    // Re-parse the original argv so the command's own action handler runs
+    await cmd.parseAsync(process.argv.slice(2), { from: 'user' });
+}
 //# sourceMappingURL=chat.js.map

package/dist/commands/credentials/endpoint-list.js

@@ -7,6 +7,7 @@ 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 { DEFAULT_PAGE_LIMIT } from '../../lib/api-types.js';
 import { Table } from '../../lib/table.js';
 export function createCredentialsEndpointListCommand() {
     const cmd = new Command('list');
@@ -15,8 +16,8 @@ export function createCredentialsEndpointListCommand() {
         .argument('<credential-id>', 'Credential ID')
         .option('--include-previous-versions', 'Include endpoints from previous versions')
         .option('--search <query>', 'Search by operation name')
-        .option('--limit <number>', 'Number of results to return', '20')
-        .option('--offset <number>', 'Offset for pagination', '0')
+        .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 (credentialId, options) => {
         const output = createOutputWriter();
         try {

package/dist/commands/credentials/list.js

@@ -6,14 +6,15 @@ import { getAuthToken } from '../../lib/auth.js';
 import { handleAxiosError } from '../../lib/errors.js';
 import { getOutputMode } from '../../lib/output-mode.js';
 import { createOutputWriter, formatCredentialsTable } from '../../lib/output.js';
+import { DEFAULT_PAGE_LIMIT } from '../../lib/api-types.js';
 export function createCredentialsListCommand() {
     const cmd = new Command('list');
     cmd
         .description('List credentials for an account')
         .requiredOption('--owner <account>', 'Account name or ID')
         .option('--search <query>', 'Filter by integration name')
-        .option('--limit <number>', 'Number of results to return', '20')
-        .option('--offset <number>', 'Offset for pagination', '0')
+        .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();
         try {

package/dist/commands/credentials/policy-list.js

@@ -6,13 +6,14 @@ import { getAuthToken } from '../../lib/auth.js';
 import { handleAxiosError } from '../../lib/errors.js';
 import { getOutputMode } from '../../lib/output-mode.js';
 import { createOutputWriter, formatPoliciesTable } from '../../lib/output.js';
+import { DEFAULT_PAGE_LIMIT } from '../../lib/api-types.js';
 export function createCredentialsPolicyListCommand() {
     const cmd = new Command('list');
     cmd
         .description('List policies for a credential')
         .argument('<credential-id>', 'Credential ID')
-        .option('--limit <number>', 'Number of results to return', '20')
-        .option('--offset <number>', 'Offset for pagination', '0')
+        .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 (credentialId, options) => {
         const output = createOutputWriter();
         try {

package/dist/commands/integration/connect.js

@@ -2,7 +2,6 @@
 // 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';
@@ -40,6 +39,7 @@ export function createIntegrationConnectCommand() {
             }
             let apiKey = options.token;
             if (!apiKey) {
+                const { default: inquirer } = await import('inquirer');
                 const answer = await inquirer.prompt([
                     {
                         type: 'password',

package/dist/commands/integration/create.js

@@ -2,7 +2,6 @@
 // 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';
@@ -66,47 +65,44 @@ export function createIntegrationCreateCommand() {
             });
             // Resolve description
             let description = options.description;
-            if (!description) {
-                if (interactive) {
-                    const answer = await inquirer.prompt([
-                        { type: 'input', name: 'description', message: 'Description:' },
-                    ]);
-                    description = answer.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) {
-                if (interactive) {
-                    const answer = await inquirer.prompt([
-                        { type: 'input', name: 'baseUrl', message: 'Base URL:' },
-                    ]);
-                    baseUrl = answer.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) {
-                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;
-                }
+            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 = [];
@@ -126,6 +122,7 @@ export function createIntegrationCreateCommand() {
             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',
@@ -151,6 +148,7 @@ export function createIntegrationCreateCommand() {
                 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:' },
@@ -205,6 +203,7 @@ export function createIntegrationCreateCommand() {
                     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',
@@ -237,6 +236,7 @@ export function createIntegrationCreateCommand() {
                 }
             }
             else if (interactive) {
+                const { default: inquirer } = await import('inquirer');
                 const answer = await inquirer.prompt([
                     {
                         type: 'confirm',

package/dist/commands/integration/list.js

@@ -6,6 +6,7 @@ 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';
+import { DEFAULT_PAGE_LIMIT } from '../../lib/api-types.js';
 const SORT_MAP = {
     updated: 'updated_at',
     newest: 'created_at',
@@ -18,8 +19,8 @@ export function createIntegrationListCommand() {
         .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')
+        .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();
         try {

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

@@ -2,7 +2,6 @@
 // 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';
@@ -59,6 +58,7 @@ export function createIntegrationOperationCreateCommand() {
                 let method = options.method;
                 let operationPath = options.path;
                 if (isInteractive()) {
+                    const { default: inquirer } = await import('inquirer');
                     if (!operation) {
                         const a = await inquirer.prompt([
                             {
@@ -110,6 +110,7 @@ export function createIntegrationOperationCreateCommand() {
                 };
                 let summary = options.summary;
                 if (!summary && isInteractive()) {
+                    const { default: inquirer } = await import('inquirer');
                     const a = await inquirer.prompt([
                         { type: 'input', name: 'val', message: 'Summary (optional):' },
                     ]);