@guildai/cli 0.7.1 → 0.8.1

package/dist/lib/agent-helpers.js

@@ -234,4 +234,73 @@ export async function buildEphemeralVersion(client, agentId, files, cwd, summary
     }
     return { version, cached: false };
 }
+// ---------------------------------------------------------------------------
+// Bundle version
+// ---------------------------------------------------------------------------
+/** Thrown when the specified bundle file cannot be found on disk. */
+export class BundleNotFoundError extends Error {
+    constructor(filePath) {
+        super(`Bundle file not found: ${filePath}`);
+        this.name = 'BundleNotFoundError';
+    }
+}
+/**
+ * Upload a pre-built bundle as an ephemeral version.
+ *
+ * The bundle file must be gzip+base64 encoded (the output of
+ * `esbuild ... | gzip | base64`). Source files are included for
+ * dashboard viewing, but the server skips its own build step because
+ * the ready-to-run artifact is already provided.
+ */
+export async function buildBundledVersion(client, agentId, bundlePath, cwd, summary) {
+    try {
+        await fs.access(bundlePath);
+    }
+    catch {
+        throw new BundleNotFoundError(bundlePath);
+    }
+    const bundle = (await fs.readFile(bundlePath, 'utf-8')).trim();
+    let files = [];
+    try {
+        files = await readAgentFiles(cwd);
+    }
+    catch {
+        // No git or missing required files — proceed with bundle-only upload
+    }
+    const initial = (await client.post(`/agents/${agentId}/versions`, {
+        version_type: 'EPHEMERAL',
+        bundle,
+        encoding: 'gzip;base64',
+        files,
+        summary,
+    }));
+    const pollResult = await pollUntilComplete({
+        resourceId: initial.id,
+        endpoint: `/versions/${initial.id}`,
+        isComplete: (r) => r.validation_status !== 'PENDING' && r.validation_status !== 'RUNNING',
+        message: 'Validating bundle...',
+        successMessage: 'Bundle validated',
+        timeoutMessage: 'Bundle validation timed out',
+        maxAttempts: 120,
+        delayMs: 1000,
+    });
+    if (!pollResult.success || !pollResult.response) {
+        throw new BuildTimeoutError('Bundle validation timed out.');
+    }
+    const version = pollResult.response;
+    if (version.validation_status === 'FAILED') {
+        let failedSteps = [];
+        try {
+            const stepsResponse = await client.get(`/versions/${version.id}/validation/steps`);
+            failedSteps = stepsResponse.steps
+                .filter((step) => step.status === 'FAILED')
+                .map((step) => ({ name: step.name, content: step.content ?? undefined }));
+        }
+        catch {
+            // Could not fetch validation details — throw with empty steps
+        }
+        throw new BuildFailedError(failedSteps);
+    }
+    return { version };
+}
 //# sourceMappingURL=agent-helpers.js.map

package/dist/lib/api-client.js

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 import axios from 'axios';
 import { getAuthToken, clearAuthToken } from './auth.js';
-import { retry, debug, GuildCLIError, ErrorCodes } from './errors.js';
+import { retry, debug, GuildCLIError, ErrorCodes, shouldClearAuthToken, } from './errors.js';
 import { getUserAgent, getGuildcoreUrl } from './config.js';
 import { getIapHeaders } from './iap.js';
 /**
@@ -69,14 +69,21 @@ export class GuildAPIClient {
                 return response.data;
             }
             catch (error) {
-                // Handle invalid/expired token - clear it and give clear error
                 if (error &&
                     typeof error === 'object' &&
                     'response' in error &&
                     error.response?.status === 401) {
-                    debug('Token rejected by server (401), clearing invalid token');
-                    await clearAuthToken();
-                    throw new GuildCLIError(ErrorCodes.AUTH_TOKEN_INVALID, 'Your authentication token is invalid or expired. Please run: guild auth login');
+                    const resp = error.response;
+                    const data = resp?.data;
+                    const message = typeof data === 'object' && data && 'message' in data
+                        ? data.message
+                        : undefined;
+                    if (shouldClearAuthToken(message)) {
+                        debug('Guild auth failure (401), clearing token');
+                        await clearAuthToken();
+                        throw new GuildCLIError(ErrorCodes.AUTH_TOKEN_INVALID, 'Your authentication token is invalid or expired. Please run: guild auth login');
+                    }
+                    debug(`Non-auth 401: ${message ?? 'no message'}`);
                 }
                 throw error;
             }

package/dist/lib/api-types.d.ts

@@ -25,6 +25,7 @@ export interface Agent {
     status: string;
     description: string | null;
     is_public?: boolean;
+    is_archived?: boolean;
     git_url?: string;
     cached_likes_count?: number;
     created_at?: string;
@@ -244,6 +245,22 @@ export interface TriggerWorkspaceAgent {
         version_number: string | null;
     };
 }
+/**
+ * Workspace owner as embedded in trigger API responses.
+ */
+export interface TriggerWorkspaceOwner {
+    id: string;
+    type: 'user' | 'organization';
+    name: string;
+}
+/**
+ * Workspace as embedded in trigger API responses.
+ */
+export interface TriggerWorkspace {
+    id: string;
+    name: string;
+    owner: TriggerWorkspaceOwner;
+}
 /**
  * Webhook trigger - fires when a third-party service sends an event.
  * Used by: trigger list, trigger get, trigger create
@@ -265,6 +282,7 @@ export interface TriggerWebhook {
     disabled_reason: TriggerDisabledReason | null;
     agent: TriggerAgent;
     workspace_agent: TriggerWorkspaceAgent | null;
+    workspace: TriggerWorkspace;
 }
 /**
  * Time trigger - fires on a schedule.
@@ -284,6 +302,7 @@ export interface TriggerTime {
     disabled_reason: TriggerDisabledReason | null;
     agent: TriggerAgent;
     workspace_agent: TriggerWorkspaceAgent | null;
+    workspace: TriggerWorkspace;
 }
 /**
  * Discriminated union of trigger types.
@@ -361,6 +380,43 @@ export interface CredentialsPolicy {
     updated_at: string;
 }
 export type CredentialsPolicyListResponse = PaginatedResponse<CredentialsPolicy>;
+export type TaskStatus = 'CREATED' | 'DISPATCHED' | 'STARTED' | 'RUNNING' | 'WAITING' | 'ERROR' | 'DONE' | 'INTERRUPTED';
+export interface TokenUsage {
+    input_tokens: number;
+    output_tokens: number;
+    cache_read_tokens: number;
+    cache_write_tokens: number;
+    total_tokens: number;
+    llm_call_count: number;
+}
+interface TaskBase {
+    id: string;
+    entity_type: string;
+    status: TaskStatus;
+    token_usage: TokenUsage | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface TaskAgent extends TaskBase {
+    entity_type: 'EntTaskAgent';
+    agent: {
+        name: string;
+        full_name?: string;
+    } | null;
+    version: {
+        id: string;
+        version_number?: string;
+    } | null;
+}
+export interface TaskTool extends TaskBase {
+    entity_type: 'EntTaskTool';
+    tool_name: string;
+    tool_call_id: string;
+    request_bytes: number;
+    response_bytes: number;
+    http_status_code: number;
+}
+export type Task = TaskAgent | TaskTool;
 /**
  * Session entity from API responses.
  * Used by: session list

package/dist/lib/auth.d.ts

@@ -40,10 +40,6 @@ export declare function startDeviceFlow(authUrl?: string, returnUrl?: string, re
  * @returns Access token if successful, null if failed/expired
  */
 export declare function pollForToken(authUrl: string, code: string, interval: number): Promise<string | null>;
-/**
- * Show beta invitation guidance for users who aren't authenticated.
- */
-export declare function showBetaGuidance(): void;
 /**
  * Perform complete login flow
  * @param returnUrl - Optional custom URL to redirect to after authentication

package/dist/lib/auth.js

@@ -185,15 +185,6 @@ export async function pollForToken(authUrl, code, interval) {
     spinner.fail('Authorization timed out');
     return null;
 }
-/**
- * Show beta invitation guidance for users who aren't authenticated.
- */
-export function showBetaGuidance() {
-    console.error('');
-    console.error(chalk.dim("Don't have an account? Guild.ai is in closed beta."));
-    console.error(chalk.dim('Request an invitation at hello@guild.ai'));
-    console.error('');
-}
 /**
  * Perform complete login flow
  * @param returnUrl - Optional custom URL to redirect to after authentication
@@ -242,7 +233,6 @@ export async function login(returnUrl, returnLabel, nonInteractive) {
             await saveAuthToken(token);
             return true;
         }
-        showBetaGuidance();
         return false;
     }
     catch (error) {
@@ -254,7 +244,6 @@ export async function login(returnUrl, returnLabel, nonInteractive) {
         if (formattedError.code) {
             console.error(chalk.dim(`\nError code: ${formattedError.code}`));
         }
-        showBetaGuidance();
         return false;
     }
 }

package/dist/lib/errors.d.ts

@@ -50,10 +50,6 @@ export declare function debug(message: string, ...args: unknown[]): void;
  * Format error for output
  */
 export declare function formatError(error: string, details: string, code?: string, stack?: string, suggestions?: string[]): CLIError;
-/**
- * Print error to stdout and exit
- */
-export declare function exitWithError(error: string, details: string, code?: string, exitCode?: number): never;
 /**
  * Get user-friendly error message for common error codes
  */
@@ -74,6 +70,11 @@ export declare function isIapError(error: unknown): boolean;
  * Check if an error is a Guild auth error
  */
 export declare function isAuthError(error: unknown): boolean;
+/**
+ * Check if a 401 response message indicates the stored auth token should be cleared.
+ * Uses exact match — only clear for known Guild auth failures.
+ */
+export declare function shouldClearAuthToken(responseMessage: string | undefined): boolean;
 /**
  * Check if an error is fatal (should not be retried)
  *

package/dist/lib/errors.js

@@ -82,14 +82,6 @@ export function formatError(error, details, code, stack, suggestions) {
     }
     return result;
 }
-/**
- * Print error to stdout and exit
- */
-export function exitWithError(error, details, code, exitCode = 1) {
-    const formattedError = formatError(error, details, code);
-    console.log(JSON.stringify(formattedError, null, 2));
-    process.exit(exitCode);
-}
 /**
  * Get user-friendly error message for common error codes
  */
@@ -280,9 +272,15 @@ const IAP_ERROR_PATTERNS = [
     'gcloud returned empty token',
 ];
 /**
- * Patterns that indicate Guild auth errors (not IAP)
+ * Messages from Guildcore that indicate a real Guild auth failure.
+ * Source: python/guildcore/core/session.py and routing.py
  */
-const AUTH_ERROR_PATTERNS = ['Not authenticated', 'Authentication required'];
+const GUILD_AUTH_FAILURE_MESSAGES = [
+    'Access token expired',
+    'Access token invalid',
+    'Session expired',
+    'Not authenticated',
+];
 /**
  * Check if an error is an IAP (Google Identity-Aware Proxy) error
  */
@@ -295,7 +293,16 @@ export function isIapError(error) {
  */
 export function isAuthError(error) {
     const message = error instanceof Error ? error.message : String(error);
-    return AUTH_ERROR_PATTERNS.some((pattern) => message.includes(pattern));
+    return GUILD_AUTH_FAILURE_MESSAGES.some((pattern) => message.includes(pattern));
+}
+/**
+ * Check if a 401 response message indicates the stored auth token should be cleared.
+ * Uses exact match — only clear for known Guild auth failures.
+ */
+export function shouldClearAuthToken(responseMessage) {
+    if (!responseMessage)
+        return false;
+    return GUILD_AUTH_FAILURE_MESSAGES.some((msg) => msg === responseMessage);
 }
 /**
  * Check if an error is fatal (should not be retried)

package/dist/lib/output.d.ts

@@ -1,10 +1,10 @@
 import { type Spinner } from './progress.js';
-import type { Agent, AgentVersion, Credentials, CredentialsPolicy, Context, Integration, IntegrationVersion, JobStep, Pagination, Session, Workspace, WorkspaceAgent, Trigger } from './api-types.js';
+import type { Agent, AgentVersion, Credentials, CredentialsPolicy, Context, Integration, IntegrationVersion, JobStep, Pagination, Session, Task, Workspace, WorkspaceAgent, Trigger } from './api-types.js';
 /**
  * Format an agent list as a human-readable table.
  * Shared by agent list and agent search commands.
  */
-export declare function formatAgentTable(agents: Agent[], pagination: Pagination): void;
+export declare function formatAgentTable(agents: Agent[], pagination: Pagination, showArchived?: boolean): void;
 /**
  * Format an integration list as a human-readable table.
  * Used by integration list command.
@@ -40,6 +40,11 @@ export declare function formatWorkspaceTable(workspaces: Workspace[], pagination
  * Used by session list command.
  */
 export declare function formatSessionTable(sessions: Session[], pagination: Pagination): void;
+/**
+ * Format a task list as a human-readable table.
+ * Used by session tasks command.
+ */
+export declare function formatTaskTable(tasks: Task[], pagination: Pagination): void;
 /**
  * Format a trigger list as a human-readable table.
  * Used by trigger list command.

package/dist/lib/output.js

@@ -42,7 +42,7 @@ function truncate(str, maxLen) {
  * Format an agent list as a human-readable table.
  * Shared by agent list and agent search commands.
  */
-export function formatAgentTable(agents, pagination) {
+export function formatAgentTable(agents, pagination, showArchived = false) {
     if (agents.length === 0) {
         console.log(chalk.dim('No agents found'));
         return;
@@ -61,10 +61,14 @@ export function formatAgentTable(agents, pagination) {
     });
     const base = getDashboardUrl();
     agents.forEach((agent) => {
-        const name = agent.full_name || agent.name;
+        const rawName = agent.full_name || agent.name;
         const agentUrl = agent.full_name ? `${base}/agents/${agent.full_name}` : '';
+        const linkedName = agentUrl ? hyperlink(rawName, agentUrl) : rawName;
+        const displayName = showArchived && agent.is_archived
+            ? linkedName + chalk.dim(' [archived]')
+            : linkedName;
         table.addRow({
-            name: agentUrl ? hyperlink(name, agentUrl) : name,
+            name: displayName,
             owner: agent.owner?.name || '',
             description: truncate(agent.description || '', 40),
             updated: agent.updated_at ? formatRelativeTime(agent.updated_at) : '',
@@ -359,6 +363,56 @@ export function formatSessionTable(sessions, pagination) {
         console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} sessions`));
     }
 }
+/**
+ * Format a task list as a human-readable table.
+ * Used by session tasks command.
+ */
+export function formatTaskTable(tasks, pagination) {
+    if (tasks.length === 0) {
+        console.log(chalk.dim('No tasks found'));
+        return;
+    }
+    const table = new Table({
+        columns: [
+            { name: 'id', title: 'ID', alignment: 'left' },
+            { name: 'name', title: 'NAME', alignment: 'left' },
+            { name: 'status', title: 'STATUS', alignment: 'left' },
+            { name: 'tokens', title: 'TOKENS', alignment: 'left' },
+            { name: 'created', title: 'CREATED', alignment: 'left' },
+        ],
+    });
+    tasks.forEach((task) => {
+        const name = task.entity_type === 'EntTaskAgent'
+            ? task.agent?.full_name || task.agent?.name || '-'
+            : task.tool_name;
+        const statusColor = task.status === 'DONE'
+            ? chalk.green
+            : task.status === 'ERROR'
+                ? chalk.red
+                : task.status === 'RUNNING' ||
+                    task.status === 'STARTED' ||
+                    task.status === 'WAITING'
+                    ? chalk.yellow
+                    : chalk.dim;
+        table.addRow({
+            id: truncate(task.id, 13),
+            name,
+            status: statusColor(task.status),
+            tokens: task.token_usage ? task.token_usage.total_tokens.toLocaleString() : '-',
+            created: task.created_at ? formatRelativeTime(task.created_at) : '',
+        });
+    });
+    table.printTable();
+    const showing = Math.min(pagination.limit, tasks.length);
+    if (pagination.has_more) {
+        const nextOffset = pagination.offset + pagination.limit;
+        console.log(`\nShowing ${showing} of ${pagination.total_count} tasks. ` +
+            chalk.dim(`Use --offset ${nextOffset} to see more.`));
+    }
+    else if (pagination.total_count > showing) {
+        console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} tasks`));
+    }
+}
 /**
  * Format a trigger list as a human-readable table.
  * Used by trigger list command.
@@ -388,8 +442,10 @@ export function formatTriggerTable(triggers, pagination) {
         const agentUrl = trigger.agent?.full_name
             ? `${base}/agents/${trigger.agent.full_name}`
             : '';
+        const ownerSegment = trigger.workspace.owner.type === 'organization' ? 'organizations' : 'users';
+        const triggerUrl = `${base}/${ownerSegment}/${trigger.workspace.owner.name}/workspaces/${trigger.workspace.name}/triggers`;
         table.addRow({
-            id: hyperlink(trigger.id, `${base}/triggers/${trigger.id}/sessions`),
+            id: hyperlink(trigger.id, triggerUrl),
             type: trigger.type,
             agent: agentUrl ? hyperlink(agentName, agentUrl) : agentName,
             status,

package/dist/lib/polling.d.ts

@@ -71,28 +71,4 @@ export interface PollResult<T = unknown> {
  * ```
  */
 export declare function pollUntilComplete<T = unknown>(options: PollOptions<T>): Promise<PollResult<T>>;
-/**
- * Agent response with status field
- */
-interface AgentStatusResponse {
-    status: string;
-    [key: string]: unknown;
-}
-/**
- * Poll an agent until it reaches a specific status
- *
- * @param agentId - Agent ID to poll
- * @param targetStatus - Status to wait for (e.g., 'READY')
- * @param options - Additional polling options
- *
- * @example
- * ```typescript
- * const result = await pollAgentStatus(agentId, 'READY');
- * if (result.success) {
- *   console.log('Agent is ready');
- * }
- * ```
- */
-export declare function pollAgentStatus(agentId: string, targetStatus: string, options?: Partial<Omit<PollOptions<AgentStatusResponse>, 'resourceId' | 'endpoint' | 'isComplete'>>): Promise<PollResult<AgentStatusResponse>>;
-export {};
 //# sourceMappingURL=polling.d.ts.map

package/dist/lib/polling.js

@@ -64,30 +64,4 @@ export async function pollUntilComplete(options) {
         attempts,
     };
 }
-/**
- * Poll an agent until it reaches a specific status
- *
- * @param agentId - Agent ID to poll
- * @param targetStatus - Status to wait for (e.g., 'READY')
- * @param options - Additional polling options
- *
- * @example
- * ```typescript
- * const result = await pollAgentStatus(agentId, 'READY');
- * if (result.success) {
- *   console.log('Agent is ready');
- * }
- * ```
- */
-export async function pollAgentStatus(agentId, targetStatus, options = {}) {
-    return pollUntilComplete({
-        resourceId: agentId,
-        endpoint: `/agents/${agentId}`,
-        isComplete: (response) => response.status === targetStatus,
-        message: options.message || 'Waiting for agent initialization...',
-        successMessage: options.successMessage || 'Agent initialization complete',
-        timeoutMessage: options.timeoutMessage || 'Agent initialization timed out after 60 seconds',
-        ...options,
-    });
-}
 //# sourceMappingURL=polling.js.map

package/dist/mcp/tools.js

@@ -387,7 +387,7 @@ export function registerTools(server, apiClient, defaultWorkspaceId, debug) {
     server.tool('guild_get_agent', 'Get details for a specific Guild agent', {
         agent_id: z
             .string()
-            .describe('The agent ID or full name (e.g. owner/agent-name)'),
+            .describe('The agent ID or full name (e.g. owner~agent-name)'),
     }, async ({ agent_id }) => {
         debugLog(debug, `guild_get_agent: ${agent_id}`);
         try {
@@ -489,7 +489,7 @@ export function registerTools(server, apiClient, defaultWorkspaceId, debug) {
         agent: z
             .string()
             .optional()
-            .describe('Agent identifier (e.g. owner/agent-name). Uses workspace default if not specified'),
+            .describe('Agent identifier (e.g. owner~agent-name). Uses workspace default if not specified'),
         workspace_id: workspaceIdParam,
     }, async ({ message, agent, workspace_id }) => {
         const wsId = workspace_id || defaultWorkspaceId;