@guildai/cli 0.9.1 → 0.11.0

package/dist/commands/agent/workspaces.js

@@ -6,14 +6,15 @@ import { getGuildcoreUrl } from '../../lib/config.js';
 import { handleAxiosError, ErrorCodes } from '../../lib/errors.js';
 import { getAgentId, resolveAgentRef } from '../../lib/agent-helpers.js';
 import { createOutputWriter, formatWorkspaceTable } from '../../lib/output.js';
-import { getOutputMode } from '../../lib/output-mode.js';
+import { isMachineReadable } from '../../lib/output-mode.js';
+import { DEFAULT_PAGE_LIMIT } from '../../lib/api-types.js';
 export function createAgentWorkspacesCommand() {
     const cmd = new Command('workspaces');
     cmd
         .description('List workspaces that use an agent')
         .argument('[identifier]', 'Agent ID or full name (e.g., owner~agent-name)')
-        .option('--limit <number>', 'Maximum number of workspaces to return', '20')
-        .option('--offset <number>', 'Number of workspaces to skip', '0')
+        .option('--limit <number>', `Maximum number of workspaces to return (default: ${DEFAULT_PAGE_LIMIT})`, String(DEFAULT_PAGE_LIMIT))
+        .option('--offset <number>', 'Number of workspaces to skip (default: 0)', '0')
         .action(async (agentIdArg, options) => {
         const output = createOutputWriter();
         const { agentId } = await getAgentId(agentIdArg);
@@ -24,7 +25,7 @@ export function createAgentWorkspacesCommand() {
         try {
             const resolvedId = await resolveAgentRef(client, agentId);
             const result = await client.get(`/agents/${resolvedId}/workspaces?limit=${limit}&offset=${offset}`);
-            if (getOutputMode() === 'json') {
+            if (isMachineReadable()) {
                 output.data(result);
             }
             else {

package/dist/commands/auth/login.js

@@ -11,11 +11,9 @@ export function createAuthLoginCommand() {
         .description('Login to Guild.ai')
         .option('--return-url <url>', 'Custom URL to redirect to after authentication')
         .option('--return-label <text>', 'Friendly label for return button (e.g., "VSCode")')
-        .option('--non-interactive', 'Skip interactive prompts (for use with coding agents)')
         .action(async (options) => {
         const output = createOutputWriter();
-        const nonInteractive = options.nonInteractive || false;
-        const success = await login(options.returnUrl, options.returnLabel, nonInteractive);
+        const success = await login(options.returnUrl, options.returnLabel);
         if (success) {
             try {
                 await configureNpmrc();

package/dist/commands/chat.d.ts

@@ -2,6 +2,15 @@ import React from 'react';
 import { Command } from 'commander';
 import { GuildAPIClient } from '../lib/api-client.js';
 import { SessionEvent, Session } from '../lib/session-events.js';
+/** Thrown when no workspace is configured (no --workspace flag, no config). */
+export declare class WorkspaceNotConfiguredError extends Error {
+    constructor();
+}
+/** Thrown when the specified workspace ID is not found in the backend. */
+export declare class WorkspaceNotFoundError extends Error {
+    readonly workspaceId: string;
+    constructor(workspaceId: string);
+}
 /**
  * ChatApp wrapper component that shows splash animation during connection
  * and then transitions to ChatUIWithConnection once connected.

package/dist/commands/chat.js

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 import React, { useState, useEffect, useRef } from 'react';
 import { Box, Text, Static, render, useInput, useApp } from 'ink';
-import { Command } from 'commander';
+import { Command, Option } from 'commander';
 import { getAuthToken } from '../lib/auth.js';
 import { GuildAPIClient } from '../lib/api-client.js';
 import { handleAxiosError, ErrorCodes, debug, isDebugMode, retry, } from '../lib/errors.js';
@@ -13,8 +13,8 @@ import chalk from 'chalk';
 import { readFileSync } from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
-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 { isUnfulfilledAgentInstallRequest, isFilteredTaskName, getTaskDisplayName, getAgentName, getAgentNotificationText, applyResponseStreamText, isDoneResponseStreamEvent, isResponseStreamEvent, isRootTaskEvent, } from '../lib/session-events.js';
+import { printResumeHint, fetchSession, fetchSessionEvents, prepareSessionResumeDisplay, } 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';
@@ -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: {} }));
@@ -90,6 +112,11 @@ function renderAssistantMessage(text, taskName) {
     const rendered = fixListItemMarkdown(marked.parse(text));
     return `${chalk.green('●')} ${chalk.bold(taskName)}\n${rendered.trim()}`;
 }
+function applyResponseStreamContentsInSequence(contents) {
+    return [...contents]
+        .sort((left, right) => left.sequence - right.sequence)
+        .reduce((currentText, content) => applyResponseStreamText(currentText, content), '');
+}
 /**
  * Output the result of a --once mode session.
  * Handles both JSON and human-readable output formats.
@@ -102,9 +129,18 @@ async function outputOnceResult(sessionId, events, mode) {
         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));
+        const responseStreamContents = new Map();
+        const doneStreamIds = [];
+        for (const event of events) {
+            if (!isResponseStreamEvent(event) || !isRootTaskEvent(event))
+                continue;
+            const streamContents = responseStreamContents.get(event.content.stream_id) ?? [];
+            streamContents.push(event.content);
+            responseStreamContents.set(event.content.stream_id, streamContents);
+            if (isDoneResponseStreamEvent(event)) {
+                doneStreamIds.push(event.content.stream_id);
+            }
+        }
         if (finalAgentMessages.length > 0) {
             const messageContent = extractMessageText(getAgentNotificationText(finalAgentMessages[finalAgentMessages.length - 1]));
             const rendered = fixListItemMarkdown(await marked(messageContent));
@@ -120,9 +156,12 @@ async function outputOnceResult(sessionId, events, mode) {
                 return;
             }
         }
-        if (streamFallbacks.length > 0) {
-            const messageContent = extractMessageText(getAgentNotificationText(streamFallbacks[streamFallbacks.length - 1]));
-            const rendered = fixListItemMarkdown(await marked(messageContent));
+        const lastDoneStreamId = doneStreamIds[doneStreamIds.length - 1];
+        const streamFallbackText = lastDoneStreamId !== undefined
+            ? applyResponseStreamContentsInSequence(responseStreamContents.get(lastDoneStreamId) ?? [])
+            : null;
+        if (streamFallbackText !== null) {
+            const rendered = fixListItemMarkdown(await marked(streamFallbackText));
             console.log(rendered.trim());
         }
     }
@@ -264,8 +303,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.');
@@ -278,6 +320,7 @@ export function ChatApp({ initialPrompt, version, workspaceId, versionId, agentN
         };
         connect();
     }, [workspaceId, initialPrompt, versionId]);
+    const chatInstanceKey = `${connectedSession?.id ?? 'pending'}:${resumeEvents?.[resumeEvents.length - 1]?.id ?? 'live'}`;
     // Render both splash and chat, but only show one at a time
     // ChatUIWithConnection is always mounted (when connected) so it can stream events in background
     return (React.createElement(React.Fragment, null,
@@ -291,7 +334,7 @@ export function ChatApp({ initialPrompt, version, workspaceId, versionId, agentN
                 }
                 // If not connected yet, ignore escape (let connection complete)
             } })),
-        phase === 'chat' && (React.createElement(ChatUIWithConnection, { initialPrompt: initialPrompt, version: version, versionId: versionId, agentName: agentName, client: connectedClient, session: connectedSession, onFirstMessage: () => setFirstMessageReceived(true), resumeEvents: resumeEvents, resumeCommand: resumeCommand, eventFilter: eventFilter })),
+        phase === 'chat' && (React.createElement(ChatUIWithConnection, { key: chatInstanceKey, initialPrompt: initialPrompt, version: version, versionId: versionId, agentName: agentName, client: connectedClient, session: connectedSession, onFirstMessage: () => setFirstMessageReceived(true), resumeEvents: resumeEvents, resumeCommand: resumeCommand, eventFilter: eventFilter })),
         (phase === 'splash' || phase === 'finalizing') &&
             connectedSession &&
             connectedClient && (React.createElement(Box, { display: "none" },
@@ -311,9 +354,9 @@ function ChatUIWithConnection({ initialPrompt, version: _version, versionId: _ve
     // Only include initial prompt when active (not during splash)
     // Static component writes to stdout even with display="none"
     // When resuming, show past events instead of initial prompt
-    const resumeDisplayMessages = resumeEvents
-        ? eventsToDisplayMessages(resumeEvents)
-        : null;
+    const [resumeDisplay] = useState(() => resumeEvents ? prepareSessionResumeDisplay(resumeEvents) : null);
+    const resumeDisplayMessages = resumeDisplay?.displayMessages ?? null;
+    const responseStreamResumeState = resumeDisplay?.responseStreamState ?? null;
     const sessionLinkMessage = isActive && preConnectedSession?.session_url
         ? [
             {
@@ -477,23 +520,53 @@ 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) => {
+    const responseStreamKeys = useRef(responseStreamResumeState?.keys ?? new Map());
+    const responseStreamContents = useRef(responseStreamResumeState?.contents ?? new Map());
+    const responseStreamTexts = useRef(responseStreamResumeState?.texts ?? new Map());
+    const responseStreamTimestamps = useRef(responseStreamResumeState?.timestamps ?? new Map());
+    const responseStreamStatuses = useRef(responseStreamResumeState?.statuses ??
+        new Map());
+    const responseStreamKeysByTask = useRef(responseStreamResumeState?.keysByTask ?? new Map());
+    const clearResponseStreamsForTask = (taskId, options = {}) => {
         if (!taskId)
             return;
         const keys = responseStreamKeysByTask.current.get(taskId);
         if (!keys?.size)
             return;
+        // Removed keys disappear from the transcript; detached keys stay rendered
+        // but are no longer tracked as active streams for future cleanup.
+        const removedKeys = new Set();
+        const detachedKeys = new Set();
         for (const [streamId, key] of responseStreamKeys.current.entries()) {
             if (keys.has(key)) {
+                if (options.preserveContinued &&
+                    responseStreamStatuses.current.get(streamId) === 'continued' &&
+                    responseStreamTexts.current.get(streamId) !== options.finalText) {
+                    responseStreamKeys.current.delete(streamId);
+                    responseStreamContents.current.delete(streamId);
+                    responseStreamTexts.current.delete(streamId);
+                    responseStreamTimestamps.current.delete(streamId);
+                    responseStreamStatuses.current.delete(streamId);
+                    detachedKeys.add(key);
+                    continue;
+                }
                 responseStreamKeys.current.delete(streamId);
+                responseStreamContents.current.delete(streamId);
+                responseStreamTexts.current.delete(streamId);
                 responseStreamTimestamps.current.delete(streamId);
+                responseStreamStatuses.current.delete(streamId);
+                removedKeys.add(key);
             }
         }
-        responseStreamKeysByTask.current.delete(taskId);
-        setMessages((prev) => prev.filter((message) => !keys.has(message.key)));
+        const inactiveKeys = new Set([...removedKeys, ...detachedKeys]);
+        const remainingKeys = new Set([...keys].filter((key) => !inactiveKeys.has(key)));
+        if (remainingKeys.size > 0) {
+            responseStreamKeysByTask.current.set(taskId, remainingKeys);
+        }
+        else {
+            responseStreamKeysByTask.current.delete(taskId);
+        }
+        setMessages((prev) => prev.filter((message) => !removedKeys.has(message.key)));
     };
     const upsertResponseStreamMessage = (event) => {
         if (!isResponseStreamEvent(event))
@@ -504,9 +577,12 @@ function ChatUIWithConnection({ initialPrompt, version: _version, versionId: _ve
         const taskId = event.task?.id;
         const existingKey = responseStreamKeys.current.get(streamId);
         if (event.content.status === 'aborted') {
+            responseStreamContents.current.delete(streamId);
+            responseStreamTexts.current.delete(streamId);
+            responseStreamTimestamps.current.delete(streamId);
+            responseStreamStatuses.current.delete(streamId);
             if (existingKey) {
                 responseStreamKeys.current.delete(streamId);
-                responseStreamTimestamps.current.delete(streamId);
                 if (taskId) {
                     const keys = responseStreamKeysByTask.current.get(taskId);
                     keys?.delete(existingKey);
@@ -517,11 +593,22 @@ function ChatUIWithConnection({ initialPrompt, version: _version, versionId: _ve
             }
             return;
         }
-        const text = event.content.text;
+        const streamContents = responseStreamContents.current.get(streamId) ?? [];
+        const existingContentIndex = streamContents.findIndex((content) => content.sequence === event.content.sequence);
+        if (existingContentIndex === -1) {
+            streamContents.push(event.content);
+        }
+        else {
+            streamContents[existingContentIndex] = event.content;
+        }
+        responseStreamContents.current.set(streamId, streamContents);
+        const text = applyResponseStreamContentsInSequence(streamContents);
         if (!text.trim())
             return;
         const key = existingKey ?? `response-stream-${streamId}`;
         responseStreamKeys.current.set(streamId, key);
+        responseStreamTexts.current.set(streamId, text);
+        responseStreamStatuses.current.set(streamId, event.content.status);
         if (taskId) {
             const keys = responseStreamKeysByTask.current.get(taskId) ?? new Set();
             keys.add(key);
@@ -773,7 +860,10 @@ function ChatUIWithConnection({ initialPrompt, version: _version, versionId: _ve
                             }
                             const text = extractMessageText(getAgentNotificationText(event));
                             if (text.trim()) {
-                                clearResponseStreamsForTask(taskInfo?.id);
+                                clearResponseStreamsForTask(taskInfo?.id, {
+                                    preserveContinued: true,
+                                    finalText: text,
+                                });
                                 const taskName = agentName || 'assistant';
                                 const messageContent = renderAssistantMessage(text, taskName);
                                 setMessages((prev) => [
@@ -842,13 +932,16 @@ 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.
                                 const contentStr = typeof event.content === 'string'
                                     ? event.content
                                     : JSON.stringify(event.content);
+                                clearResponseStreamsForTask(taskInfo.id, {
+                                    preserveContinued: true,
+                                    finalText: contentStr,
+                                });
                                 if (contentStr && contentStr !== '{}' && contentStr !== 'null') {
                                     const rendered = fixListItemMarkdown(marked.parse(contentStr));
                                     const taskName = agentName || 'assistant';
@@ -1108,7 +1201,7 @@ export async function createSession(client, workspaceId, initialPrompt, versionI
         }
     }
     if (!workspaceId) {
-        throw new Error('No workspace configured. Run: guild workspace select, or pass --workspace <id>');
+        throw new WorkspaceNotConfiguredError();
     }
     progress('Creating session');
     const sessionData = {
@@ -1127,7 +1220,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;
     }
@@ -1145,11 +1238,13 @@ export function createChatCommand() {
         .argument('[prompt...]', 'Optional initial prompt (multiple words)')
         .option('--agent <identifier>', 'Agent ID or full name, e.g., foo~bar (default: assistant)')
         .option('--once', 'One-shot mode: send message, wait for response, exit (non-interactive)')
-        .option('--mode <format>', 'Machine-readable output format: json or jsonl')
         .option('--workspace <identifier>', 'Workspace ID or full name (e.g., owner/workspace-name)')
         .option('--no-splash', 'Skip the splash screen animation')
         .option('--resume <session-id>', 'Resume an existing session')
         .option('--events <types>', 'Event types to show (default: user). Shorthands: none, user, system, all, or comma-separated type names (e.g. agent_console,llm_start)')
+        // Accept --mode so `guild chat --mode json` works when re-parsed.
+        // The actual value is read from process.argv by getOutputMode().
+        .addOption(new Option('--mode <format>').hideHelp())
         .addHelpText('after', '\nTo chat with a local agent under development: guild agent chat')
         .action(async (promptArgs, options) => {
         const initialPrompt = promptArgs.length > 0 ? promptArgs.join(' ') : 'Hello';
@@ -1220,7 +1315,8 @@ export function createChatCommand() {
                     if (hasRootTaskError) {
                         debug('Found error event from root agent, exiting --once mode');
                         const errorEvents = allEvents.filter((e) => e.type === 'runtime_error' || e.type === 'agent_notification_error');
-                        if (errorEvents.length > 0 && !options.mode) {
+                        const outputMode = getOutputMode();
+                        if (errorEvents.length > 0 && outputMode === 'interactive') {
                             const lastError = errorEvents[errorEvents.length - 1];
                             const content = lastError.content;
                             if (content?.data) {
@@ -1230,7 +1326,7 @@ export function createChatCommand() {
                                 console.error(chalk.red('Agent failed to start'));
                             }
                         }
-                        else if (options.mode === 'json') {
+                        else if (outputMode === 'json') {
                             console.log(JSON.stringify({
                                 session_id: session.id,
                                 events: allEvents,
@@ -1241,14 +1337,14 @@ export function createChatCommand() {
                     }
                     if (hasRootTaskDone || hasAgentMessage || hasUIPromptMessage) {
                         debug('Found completion event from root agent, exiting --once mode');
-                        await outputOnceResult(session.id, allEvents, options.mode);
+                        await outputOnceResult(session.id, allEvents, getOutputMode());
                         process.exit(0);
                     }
                     // Timeout if no activity for too long
                     if (inactivityCounter >= maxInactivityAttempts) {
                         debug(`Inactivity timeout reached (${maxInactivityAttempts} attempts with no new events)`);
                         debug(`Exiting with ${allEvents.length} events total`);
-                        await outputOnceResult(session.id, allEvents, options.mode);
+                        await outputOnceResult(session.id, allEvents, getOutputMode());
                         process.exit(0);
                     }
                 }
@@ -1256,6 +1352,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);

package/dist/commands/config/get.js

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 import { Command } from 'commander';
 import { loadConfig, } from '../../lib/guild-config.js';
-import { getOutputMode } from '../../lib/output-mode.js';
+import { isMachineReadable } from '../../lib/output-mode.js';
 import { createOutputWriter } from '../../lib/output.js';
 /**
  * All valid config keys across global and local configs.
@@ -25,7 +25,7 @@ export function createConfigGetCommand() {
         .action(async (key) => {
         const output = createOutputWriter();
         const config = await loadConfig();
-        const mode = getOutputMode();
+        const jsonMode = isMachineReadable();
         if (!ALL_VALID_KEYS.includes(key)) {
             output.error(`Unknown config key: ${key}\n\nValid keys:\n  Global: ${VALID_GLOBAL_KEYS.join(', ')}\n  Local:  ${VALID_LOCAL_KEYS.join(', ')}`);
             process.exit(1);
@@ -44,7 +44,7 @@ export function createConfigGetCommand() {
             source = 'local';
         }
         if (value === undefined) {
-            if (mode === 'json') {
+            if (jsonMode) {
                 output.data({ key, value: null, source: null });
             }
             else {
@@ -52,7 +52,7 @@ export function createConfigGetCommand() {
             }
             process.exit(1);
         }
-        if (mode === 'json') {
+        if (jsonMode) {
             output.data({ key, value, source });
         }
         else {

package/dist/commands/config/list.js

@@ -3,15 +3,14 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { loadConfig } from '../../lib/guild-config.js';
-import { getOutputMode } from '../../lib/output-mode.js';
+import { isMachineReadable } from '../../lib/output-mode.js';
 import { createOutputWriter } from '../../lib/output.js';
 export function createConfigListCommand() {
     const cmd = new Command('list');
     cmd.description('Show all configuration values').action(async () => {
         const output = createOutputWriter();
         const config = await loadConfig();
-        const mode = getOutputMode();
-        if (mode === 'json') {
+        if (isMachineReadable()) {
             output.data({
                 global: config.global || null,
                 local: config.local || null,

package/dist/commands/config/path.js

@@ -4,7 +4,7 @@ import { Command } from 'commander';
 import chalk from 'chalk';
 import * as fs from 'fs/promises';
 import { getGlobalConfigPath, getLocalConfigPath } from '../../lib/guild-config.js';
-import { getOutputMode } from '../../lib/output-mode.js';
+import { isMachineReadable } from '../../lib/output-mode.js';
 import { createOutputWriter } from '../../lib/output.js';
 async function fileExists(filePath) {
     return fs
@@ -18,10 +18,9 @@ export function createConfigPathCommand() {
         const output = createOutputWriter();
         const globalPath = getGlobalConfigPath();
         const localPath = getLocalConfigPath();
-        const mode = getOutputMode();
         const globalExists = await fileExists(globalPath);
         const localExists = await fileExists(localPath);
-        if (mode === 'json') {
+        if (isMachineReadable()) {
             output.data({
                 global: { path: globalPath, exists: globalExists },
                 local: { path: localPath, exists: localExists },

package/dist/commands/config/set.js

@@ -3,7 +3,7 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { saveGlobalConfig } from '../../lib/guild-config.js';
-import { getOutputMode } from '../../lib/output-mode.js';
+import { isMachineReadable } from '../../lib/output-mode.js';
 import { createOutputWriter } from '../../lib/output.js';
 import { GuildAPIClient } from '../../lib/api-client.js';
 import { debug } from '../../lib/errors.js';
@@ -46,8 +46,8 @@ async function resolveWorkspaceName(workspaceId) {
         return undefined;
     }
 }
-function printResult(key, value, mode, output) {
-    if (mode === 'json') {
+function printResult(key, value, jsonMode, output) {
+    if (jsonMode) {
         output.data({ key, value });
     }
     else {
@@ -62,7 +62,7 @@ export function createConfigSetCommand() {
         .argument('<value>', 'Value to set')
         .action(async (key, value) => {
         const output = createOutputWriter();
-        const mode = getOutputMode();
+        const jsonMode = isMachineReadable();
         if (!VALID_GLOBAL_KEYS.includes(key)) {
             output.error(`Unknown config key: ${key}\n\nValid keys:\n${VALID_GLOBAL_KEYS.map((k) => `  ${k}`).join('\n')}`);
             process.exit(1);
@@ -71,7 +71,7 @@ export function createConfigSetCommand() {
         if (BOOLEAN_KEYS.has(typedKey)) {
             const boolValue = parseBoolean(value, key, output);
             await saveGlobalConfig({ [typedKey]: boolValue });
-            printResult(key, boolValue, mode, output);
+            printResult(key, boolValue, jsonMode, output);
             return;
         }
         if (typedKey === 'default_workspace') {
@@ -80,14 +80,14 @@ export function createConfigSetCommand() {
                 default_workspace: value,
                 default_workspace_name: name,
             });
-            printResult(key, value, mode, output);
+            printResult(key, value, jsonMode, output);
             if (name) {
-                if (mode !== 'json') {
+                if (!jsonMode) {
                     output.progress(`  Workspace name: ${name}`);
                 }
             }
             else {
-                if (mode !== 'json') {
+                if (!jsonMode) {
                     output.error('Could not resolve workspace name (not authenticated?)');
                 }
             }
@@ -111,21 +111,21 @@ export function createConfigSetCommand() {
                 default_owner: ownerId,
                 default_owner_name: ownerName,
             });
-            printResult(key, ownerId, mode, output);
+            printResult(key, ownerId, jsonMode, output);
             if (ownerName) {
-                if (mode !== 'json') {
+                if (!jsonMode) {
                     output.progress(`  Owner name: ${ownerName}`);
                 }
             }
             else {
-                if (mode !== 'json') {
+                if (!jsonMode) {
                     output.error('Could not resolve owner name (not authenticated?)');
                 }
             }
             return;
         }
         await saveGlobalConfig({ [typedKey]: value });
-        printResult(key, value, mode, output);
+        printResult(key, value, jsonMode, output);
     });
     return cmd;
 }

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

@@ -5,8 +5,9 @@ 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 { isMachineReadable } 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 {
@@ -36,7 +37,7 @@ export function createCredentialsEndpointListCommand() {
                 params.append('search', options.search);
             }
             const response = await client.get(`/credentials/${credentialId}/endpoints?${params.toString()}`);
-            if (getOutputMode() === 'json') {
+            if (isMachineReadable()) {
                 console.log(JSON.stringify(response, null, 2));
             }
             else {

package/dist/commands/credentials/list.js

@@ -4,16 +4,17 @@ 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 { isMachineReadable } 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 {
@@ -31,7 +32,7 @@ export function createCredentialsListCommand() {
                 params.append('search', options.search);
             }
             const response = await client.get(`/accounts/${accountId}/credentials?${params.toString()}`);
-            if (getOutputMode() === 'json') {
+            if (isMachineReadable()) {
                 console.log(JSON.stringify(response, null, 2));
             }
             else {