@guildai/cli 0.6.1 → 0.6.2

package/dist/commands/agent/publish.js

@@ -4,8 +4,8 @@ import { Command } from 'commander';
 import { GuildAPIClient } from '../../lib/api-client.js';
 import { getAgentId, resolveAgentRef } from '../../lib/agent-helpers.js';
 import { handleAxiosError, ErrorCodes } from '../../lib/errors.js';
-import { pollUntilComplete } from '../../lib/polling.js';
 import { createOutputWriter } from '../../lib/output.js';
+import { waitForValidation, waitForPublish } from '../../lib/version-helpers.js';
 export function createAgentPublishCommand() {
     const cmd = new Command('publish');
     cmd
@@ -37,71 +37,31 @@ export function createAgentPublishCommand() {
                 process.exit(1);
             }
             // Check validation status before attempting publish
-            let validationStatus = versionToPublish.validation_status;
             let currentVersion = versionToPublish;
+            const validationStatus = currentVersion.validation_status;
             if (validationStatus === 'PENDING' || validationStatus === 'RUNNING') {
                 if (options.wait) {
-                    // Wait for validation to complete
-                    const result = await pollUntilComplete({
-                        resourceId: versionToPublish.id,
-                        endpoint: `/versions/${versionToPublish.id}`,
-                        isComplete: (response) => response.validation_status !== 'PENDING' &&
-                            response.validation_status !== 'RUNNING',
-                        message: 'Waiting for validation to complete...',
-                        successMessage: 'Validation complete',
-                        timeoutMessage: 'Validation timed out',
-                        maxAttempts: 120, // 2 minutes
-                        delayMs: 1000,
-                    });
-                    if (!result.success || !result.response) {
-                        output.error('Validation did not complete in time', 'Check status manually:\n  guild agent versions');
-                        process.exit(1);
-                    }
-                    currentVersion = result.response;
-                    validationStatus = currentVersion.validation_status;
-                    // Re-check validation status after waiting - will be handled below
-                    // by the main validation check
+                    currentVersion = await waitForValidation(currentVersion.id, output);
                 }
                 else {
-                    output.error('Cannot publish: validation is still in progress', `Validation status: ${validationStatus === 'PENDING' ? 'Waiting to start' : 'Running'}\n\nThe version number is extracted from package.json during validation.\n\nOptions:\n  • Wait for validation: guild agent publish --wait\n  • Check status: guild agent versions`);
+                    output.error('Cannot publish: validation is still in progress', `Validation status: ${validationStatus === 'PENDING' ? 'Waiting to start' : 'Running'}\n\nOptions:\n  • Wait for validation: guild agent publish --wait\n  • Check status: guild agent versions`);
                     process.exit(1);
                 }
             }
-            if (validationStatus === 'FAILED') {
-                // Fetch validation steps to show the actual error
-                let failureDetails = '';
-                try {
-                    const stepsResponse = await client.get(`/versions/${currentVersion.id}/validation/steps`);
-                    const failedSteps = stepsResponse.steps.filter((step) => step.status === 'FAILED');
-                    if (failedSteps.length > 0) {
-                        const stepMessages = failedSteps.map((step) => {
-                            let msg = `Step "${step.name}" failed:`;
-                            if (step.content) {
-                                msg += `\n  ${step.content}`;
-                            }
-                            return msg;
-                        });
-                        failureDetails = stepMessages.join('\n\n');
-                    }
-                    else {
-                        failureDetails =
-                            'No failed steps found. Check validation logs for details.';
-                    }
-                }
-                catch {
-                    // If we can't fetch steps, just show generic message
-                    failureDetails = 'Could not fetch validation details.';
-                }
-                output.error('Cannot publish: validation failed', `${failureDetails}\n\nFix the issues, then save a new version:\n  guild agent save --message "Fix validation errors"`);
+            else if (validationStatus === 'FAILED') {
+                output.error('Cannot publish: validation failed', 'Fix the issues, then save a new version:\n  guild agent save --message "Fix validation errors"');
                 process.exit(1);
             }
-            // Note: version_number is only set after validation extracts it from package.json,
-            // and only enforced at publish time (drafts don't require versions)
             // Publish version
-            await client.post(`/versions/${currentVersion.id}/publish`, {});
+            currentVersion = await client.post(`/versions/${currentVersion.id}/publish`, {});
+            if (options.wait && currentVersion.status !== 'PUBLISHED') {
+                currentVersion = await waitForPublish(currentVersion.id, output);
+            }
             const details = {
                 agent: `${currentVersion.agent?.name || config?.name || agentId}${config ? '' : ` (${agentId})`}`,
-                status: 'DRAFT → PUBLISHED',
+                status: currentVersion.status === 'PUBLISHED'
+                    ? 'DRAFT → PUBLISHED'
+                    : 'DRAFT → PUBLISHING',
             };
             if (currentVersion.version_number) {
                 details.version = currentVersion.version_number;

package/dist/commands/agent/save.js

@@ -9,7 +9,7 @@ import * as fs from 'fs/promises';
 import * as path from 'path';
 import { getAuthenticatedUrl } from '../../lib/auth.js';
 import { runGit, GitError, formatGitError } from '../../lib/git.js';
-import { pollUntilComplete } from '../../lib/polling.js';
+import { waitForValidation, waitForPublish } from '../../lib/version-helpers.js';
 export function createAgentSaveCommand() {
     const cmd = new Command('save');
     cmd
@@ -255,58 +255,18 @@ export function createAgentSaveCommand() {
                 version_type: 'COMMITTED',
             });
             output.progress(`✓ Created version (${version.id})`);
-            // --publish implies --wait
-            const shouldWait = options.wait || options.publish;
-            // If --wait or --publish, wait for validation to complete
-            if (shouldWait) {
-                const pollResult = await pollUntilComplete({
-                    resourceId: version.id,
-                    endpoint: `/versions/${version.id}`,
-                    isComplete: (response) => response.validation_status !== 'PENDING' &&
-                        response.validation_status !== 'RUNNING',
-                    message: 'Waiting for validation to complete...',
-                    successMessage: 'Validation complete',
-                    timeoutMessage: 'Validation timed out',
-                    maxAttempts: 120, // 2 minutes
-                    delayMs: 1000,
-                });
-                if (!pollResult.success || !pollResult.response) {
-                    output.error('Validation did not complete in time', 'Check status manually:\n  guild agent versions');
-                    process.exit(1);
-                }
-                version = pollResult.response;
-                // Check validation status
-                if (version.validation_status === 'FAILED') {
-                    let failureDetails = '';
-                    // Fetch validation steps to show the actual error
-                    try {
-                        const stepsResponse = await client.get(`/versions/${version.id}/validation/steps`);
-                        const failedSteps = stepsResponse.steps.filter((step) => step.status === 'FAILED');
-                        if (failedSteps.length > 0) {
-                            const stepMessages = failedSteps.map((step) => step.content
-                                ? `Step "${step.name}" failed: ${step.content}`
-                                : `Step "${step.name}" failed`);
-                            failureDetails = stepMessages.join('\n');
-                        }
-                        else {
-                            failureDetails =
-                                'No failed steps found. Check validation logs for details.';
-                        }
-                    }
-                    catch {
-                        failureDetails = 'Could not fetch validation details.';
-                    }
-                    failureDetails +=
-                        '\n\nFix the issues, commit, and save a new version:\n  git add . && git commit -m "Fix validation errors"\n  guild agent save';
-                    output.error('Validation failed', failureDetails);
-                    process.exit(1);
-                }
+            if (options.wait) {
+                version = await waitForValidation(version.id, output);
             }
-            // If --publish and validation passed, publish the version
             if (options.publish) {
                 output.progress('Validation passed, publishing...');
                 version = await client.post(`/versions/${version.id}/publish`, {});
-                output.progress('✓ Published');
+                if (options.wait && version.status !== 'PUBLISHED') {
+                    version = await waitForPublish(version.id, output);
+                }
+                else {
+                    output.progress('✓ Published');
+                }
             }
             output.progress('');
             output.progress('Version details:');
@@ -317,10 +277,14 @@ export function createAgentSaveCommand() {
                 output.progress(`  Published at: ${version.published_at}`);
             }
             output.progress(`  Summary: ${version.summary}`);
-            if (options.publish) {
+            if (options.publish && version.status === 'PUBLISHED') {
                 output.progress('');
                 output.progress('Version is now published and available in the catalog.');
             }
+            else if (options.publish) {
+                output.progress('');
+                output.progress('Publish is in progress. Use --wait to wait for completion.');
+            }
             else {
                 output.progress('');
                 output.progress('To publish this version:');

package/dist/commands/chat.js

@@ -485,9 +485,9 @@ function ChatUIWithConnection({ initialPrompt, version: _version, versionId: _ve
                 isPollingTasks.current = false;
             }
         };
-        // Poll immediately and then every second (like web)
+        // Poll immediately and then every 2 seconds
         pollTasks();
-        const interval = setInterval(pollTasks, 1000);
+        const interval = setInterval(pollTasks, 2000);
         return () => {
             clearInterval(interval);
         };
@@ -684,7 +684,7 @@ function ChatUIWithConnection({ initialPrompt, version: _version, versionId: _ve
                 isPolling.current = false;
             }
         };
-        pollInterval.current = setInterval(poll, 500);
+        pollInterval.current = setInterval(poll, 2000);
         poll();
         return () => {
             if (pollInterval.current) {
@@ -972,7 +972,7 @@ export function createChatCommand() {
                 // Timeout after 5 minutes of INACTIVITY (no new messages)
                 // Agent initialization can take 1-2 minutes with no events
                 const inactivityTimeoutMs = 300000; // 5 minutes
-                const pollIntervalMs = 500;
+                const pollIntervalMs = 2000;
                 const maxInactivityAttempts = inactivityTimeoutMs / pollIntervalMs;
                 let lastSeenEventId;
                 const allEvents = [];

package/dist/lib/session-polling.js

@@ -46,7 +46,7 @@ export async function pollForResponse(client, sessionId, afterEventId, maxWaitTi
         if (lastAgentRuntimeDone !== null) {
             return { response: lastAgentRuntimeDone, lastEventId: fromId };
         }
-        await new Promise((resolve) => setTimeout(resolve, 500));
+        await new Promise((resolve) => setTimeout(resolve, 2000));
     }
     return { response: null, lastEventId: fromId };
 }

package/dist/lib/version-helpers.d.ts

@@ -0,0 +1,15 @@
+import type { OutputWriter } from './output.js';
+import type { AgentVersion } from './api-types.js';
+/**
+ * Poll until a version's validation completes, then check the result.
+ * Exits the process on timeout or validation failure.
+ * Returns the updated version on success.
+ */
+export declare function waitForValidation(versionId: string, output: OutputWriter): Promise<AgentVersion>;
+/**
+ * Poll until a version's publish completes (PUBLISHING → PUBLISHED).
+ * Exits the process on timeout or failure.
+ * Returns the updated version on success.
+ */
+export declare function waitForPublish(versionId: string, output: OutputWriter): Promise<AgentVersion>;
+//# sourceMappingURL=version-helpers.d.ts.map

package/dist/lib/version-helpers.js

@@ -0,0 +1,83 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+import { GuildAPIClient } from './api-client.js';
+import { pollUntilComplete } from './polling.js';
+/**
+ * Poll until a version's validation completes, then check the result.
+ * Exits the process on timeout or validation failure.
+ * Returns the updated version on success.
+ */
+export async function waitForValidation(versionId, output) {
+    const pollResult = await pollUntilComplete({
+        resourceId: versionId,
+        endpoint: `/versions/${versionId}`,
+        isComplete: (response) => response.validation_status !== 'PENDING' &&
+            response.validation_status !== 'RUNNING',
+        message: 'Waiting for validation to complete...',
+        successMessage: 'Validation complete',
+        timeoutMessage: 'Validation timed out',
+        maxAttempts: 120,
+        delayMs: 1000,
+    });
+    if (!pollResult.success || !pollResult.response) {
+        output.error('Validation did not complete in time', 'Check status manually:\n  guild agent versions');
+        process.exit(1);
+    }
+    const version = pollResult.response;
+    if (version.validation_status === 'FAILED') {
+        const details = await fetchValidationFailureDetails(version.id);
+        output.error('Validation failed', details);
+        process.exit(1);
+    }
+    return version;
+}
+/**
+ * Fetch validation step details for a failed version.
+ */
+async function fetchValidationFailureDetails(versionId) {
+    const client = new GuildAPIClient();
+    let failureDetails = '';
+    try {
+        const stepsResponse = await client.get(`/versions/${versionId}/validation/steps`);
+        const failedSteps = stepsResponse.steps.filter((step) => step.status === 'FAILED');
+        if (failedSteps.length > 0) {
+            failureDetails = failedSteps
+                .map((step) => step.content
+                ? `Step "${step.name}" failed: ${step.content}`
+                : `Step "${step.name}" failed`)
+                .join('\n');
+        }
+        else {
+            failureDetails = 'No failed steps found. Check validation logs for details.';
+        }
+    }
+    catch {
+        failureDetails = 'Could not fetch validation details.';
+    }
+    failureDetails +=
+        '\n\nFix the issues, then save a new version:\n  guild agent save --message "Fix validation errors"';
+    return failureDetails;
+}
+/**
+ * Poll until a version's publish completes (PUBLISHING → PUBLISHED).
+ * Exits the process on timeout or failure.
+ * Returns the updated version on success.
+ */
+export async function waitForPublish(versionId, output) {
+    const pollResult = await pollUntilComplete({
+        resourceId: versionId,
+        endpoint: `/versions/${versionId}`,
+        isComplete: (response) => response.status === 'PUBLISHED' || response.status === 'FAILED',
+        message: 'Waiting for publish to complete...',
+        successMessage: 'Published',
+        timeoutMessage: 'Publish timed out',
+        maxAttempts: 60,
+        delayMs: 1000,
+    });
+    if (!pollResult.success || pollResult.response?.status !== 'PUBLISHED') {
+        output.error('Publish did not complete in time', 'Check status manually:\n  guild agent versions');
+        process.exit(1);
+    }
+    return pollResult.response;
+}
+//# sourceMappingURL=version-helpers.js.map

package/dist/mcp/tools.js

@@ -4,7 +4,7 @@ import { z } from 'zod';
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
-const POLL_INTERVAL_MS = 500;
+const POLL_INTERVAL_MS = 2000;
 const POLL_TIMEOUT_MS = 120_000;
 // ---------------------------------------------------------------------------
 // Helpers

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guildai/cli",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "Guild.ai CLI - Build, test, and deploy AI agents",
   "type": "module",
   "main": "dist/index.js",