@guildai/cli 0.5.12 → 0.6.0

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

@@ -1,4 +1,12 @@
 import { LocalConfig } from './guild-config.js';
+import { GuildAPIClient } from './api-client.js';
+/**
+ * Resolve an agent identifier to a fully-qualified form.
+ *
+ * If the identifier already contains `/` or is a UUID, return it verbatim.
+ * Otherwise, resolve the default owner and prepend `owner.name/`.
+ */
+export declare function resolveAgentRef(client: GuildAPIClient, identifier: string): Promise<string>;
 /**
  * Get agent ID from argument or guild.json in current directory
  * @param agentIdArg - Optional agent ID from command argument

package/dist/lib/agent-helpers.js

@@ -4,6 +4,21 @@ import * as fs from 'fs/promises';
 import * as path from 'path';
 import { loadLocalConfig } from './guild-config.js';
 import { runGit } from './git.js';
+import { resolveOwnerId } from './owner-helpers.js';
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * Resolve an agent identifier to a fully-qualified form.
+ *
+ * If the identifier already contains `/` or is a UUID, return it verbatim.
+ * Otherwise, resolve the default owner and prepend `owner.name/`.
+ */
+export async function resolveAgentRef(client, identifier) {
+    if (identifier.includes('/') || UUID_RE.test(identifier)) {
+        return identifier;
+    }
+    const owner = await resolveOwnerId({ client, interactive: false });
+    return `${owner.name}/${identifier}`;
+}
 /**
  * Get agent ID from argument or guild.json in current directory
  * @param agentIdArg - Optional agent ID from command argument

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

@@ -204,6 +204,26 @@ export interface AgentVersionDetail {
         description: string;
     };
 }
+/**
+ * Webhook config nested in integration responses.
+ * Used by: trigger create (to resolve webhook_config_id)
+ */
+export interface IntegrationWebhookConfig {
+    id: string;
+    enabled: boolean;
+    events: Record<string, string[]>;
+}
+/**
+ * Integration entity from the API.
+ * Used by: trigger create (to resolve webhook_config_id from integration name)
+ */
+export interface Integration {
+    id: string;
+    name: string;
+    full_name: string;
+    service?: string | null;
+    webhook_config: IntegrationWebhookConfig | null;
+}
 export type TriggerType = 'webhook' | 'time';
 import { WEBHOOK_SERVICES, type WebhookService, TIME_TRIGGER_FREQUENCIES, type TimeTriggerFrequency } from './generated-types.js';
 export { WEBHOOK_SERVICES, type WebhookService, TIME_TRIGGER_FREQUENCIES, type TimeTriggerFrequency, };
@@ -239,7 +259,6 @@ export interface TriggerWorkspaceAgent {
 export interface TriggerWebhook {
     id: string;
     type: 'webhook';
-    service: WebhookService;
     event_type: string | null;
     action: string | null;
     service_config?: {
@@ -248,6 +267,7 @@ export interface TriggerWebhook {
         project?: string;
         jql_filter?: string;
     } | Record<string, unknown>;
+    integration: Integration;
     created_at: string;
     deactivated_at: string | null;
     disabled_reason: TriggerDisabledReason | null;
@@ -315,101 +335,55 @@ export interface Organization {
     viewer_role: 'ADMIN' | 'MEMBER' | null;
 }
 export type OrganizationListResponse = PaginatedResponse<Organization>;
-/**
- * Session entity from API responses.
- * Used by: session list, container list (as owner)
- */
-export interface Session {
+export interface Credentials {
     id: string;
-    session_type: 'chat' | 'agent_test' | 'time' | 'webhook';
-    name?: string;
-    workspace?: {
+    integration: {
+        id: string;
+        name: string;
+        full_name: string;
+    };
+    creator: {
         id: string;
         name: string;
     };
     created_at: string;
     updated_at: string;
 }
-export type ContainerStatus = 'STARTING' | 'RUNNING' | 'ERRORED' | 'DESTROYED';
-/**
- * Container image entity from the API.
- */
-export interface ContainerImage {
+export type CredentialsListResponse = PaginatedResponse<Credentials>;
+export interface CredentialsPolicy {
     id: string;
-    name: string;
-    image_name: string;
-    tag: string;
-    is_public: boolean;
+    decision: 'ALLOW' | 'DENY';
+    operations: string[] | null;
+    resources: Record<string, string[]> | null;
+    workspaces: {
+        id: string;
+        name: string;
+        full_name?: string;
+    }[];
+    agents: {
+        id: string;
+        name: string;
+        full_name?: string;
+    }[];
     created_at: string;
     updated_at: string;
 }
+export type CredentialsPolicyListResponse = PaginatedResponse<CredentialsPolicy>;
 /**
- * The actor that created the container (user or task agent).
+ * Session entity from API responses.
+ * Used by: session list
  */
-export interface ContainerActor {
+export interface Session {
     id: string;
-    entity_type: string;
+    session_type: 'chat' | 'agent_test' | 'time' | 'webhook';
     name?: string;
-    full_name?: string;
-}
-/**
- * Container entity from the API.
- * Used by: container list
- */
-export interface Container {
-    id: string;
-    status: ContainerStatus;
-    owner: Session;
-    created_by: ContainerActor;
-    image: ContainerImage;
-    created_at: string;
-    updated_at: string;
-}
-export type ContainerListResponse = PaginatedResponse<Container>;
-/**
- * Container image as returned in list responses.
- */
-export interface ContainerImageListItem {
-    id: string;
-    name: string;
-    image_name: string;
-    tag: string;
-    is_public: boolean;
-    created_at: string;
-    updated_at: string;
-}
-export type ContainerImageListResponse = PaginatedResponse<ContainerImageListItem>;
-export type ContainerEventStatus = 'PENDING' | 'ERROR' | 'SUCCESS';
-/**
- * Base fields shared by all container events.
- */
-export interface ContainerEventBase {
-    id: string;
-    entity_type: string;
-    actor: ContainerActor;
-    status: ContainerEventStatus;
-    completed_at: string | null;
-    error: string | null;
+    workspace?: {
+        id: string;
+        name: string;
+    };
     created_at: string;
     updated_at: string;
 }
-export interface ContainerEventCreate extends ContainerEventBase {
-    entity_type: 'EntContainerEventCreate';
-    is_local: boolean;
-}
-export interface ContainerEventDestroy extends ContainerEventBase {
-    entity_type: 'EntContainerEventDestroy';
-    found: boolean | null;
-}
-export interface ContainerEventCommand extends ContainerEventBase {
-    entity_type: 'EntContainerEventCommand';
-    command: string;
-    return_code: number | null;
-    stdout: string | null;
-    stderr: string | null;
-}
-export type ContainerEvent = ContainerEventCreate | ContainerEventDestroy | ContainerEventCommand;
-export type ContainerEventListResponse = PaginatedResponse<ContainerEvent>;
 export type JobType = 'VALIDATION' | 'PUBLISH' | 'PUBLISH_PRE_CHECK';
 export type JobStatus = 'PENDING' | 'RUNNING' | 'SUCCEEDED' | 'FAILED' | 'ERRORED' | 'CANCELLED';
 export type JobStepStatus = 'PENDING' | 'RUNNING' | 'SUCCEEDED' | 'FAILED' | 'SKIPPED' | 'ERRORED';

package/dist/lib/auth.js

@@ -137,6 +137,7 @@ export async function startDeviceFlow(authUrl = getGuildcoreUrl(), returnUrl, re
  * @returns Access token if successful, null if failed/expired
  */
 export async function pollForToken(authUrl, code, interval) {
+    const isTTY = process.stderr.isTTY || false;
     const spinner = createSpinner('Waiting for authorization...');
     spinner.start();
     const maxAttempts = 90; // 3 minutes (90 * 2 seconds)
@@ -167,7 +168,9 @@ export async function pollForToken(authUrl, code, interval) {
                 }
                 if (error.response?.data?.error === 'authorization_pending' ||
                     error.response?.data?.error === 'slow_down') {
-                    spinner.text = `Waiting for authorization... (${attempts}/${maxAttempts})`;
+                    if (isTTY) {
+                        spinner.text = `Waiting for authorization... (${attempts}/${maxAttempts})`;
+                    }
                     continue;
                 }
             }
@@ -201,13 +204,13 @@ export async function login(returnUrl, returnLabel, noBrowser) {
     try {
         console.log(chalk.bold('\nGuild.ai Authentication'));
         const deviceCode = await startDeviceFlow(authUrl, returnUrl, returnLabel);
-        // Display styled verification code box
-        displayVerificationCode(deviceCode.user_code, deviceCode.verification_uri_complete);
         const skipBrowser = noBrowser || process.stdin.isTTY !== true;
         if (skipBrowser) {
-            console.log(chalk.dim('Open the URL above in your browser to complete authentication.'));
+            console.log(`\nVerification code: ${deviceCode.user_code}`);
+            console.log(`Open to authenticate: ${deviceCode.verification_uri_complete}\n`);
         }
         else {
+            displayVerificationCode(deviceCode.user_code, deviceCode.verification_uri_complete);
             // Wait for user to press Enter before opening browser
             // This gives them time to see and copy the code before browser opens
             // Critical for VSCode integration where browser may open full screen

package/dist/lib/output.d.ts

@@ -1,5 +1,5 @@
 import { type Spinner } from './progress.js';
-import type { Agent, AgentVersion, Container, ContainerEvent, ContainerImageListItem, Context, JobStep, Pagination, Session, Workspace, WorkspaceAgent, Trigger } from './api-types.js';
+import type { Agent, AgentVersion, Credentials, CredentialsPolicy, Context, JobStep, Pagination, Session, Workspace, WorkspaceAgent, Trigger } from './api-types.js';
 /**
  * Format an agent list as a human-readable table.
  * Shared by agent list and agent search commands.
@@ -35,21 +35,8 @@ export declare function formatSessionTable(sessions: Session[], pagination: Pagi
  * Used by trigger list command.
  */
 export declare function formatTriggerTable(triggers: Trigger[], pagination: Pagination): void;
-/**
- * Format a container list as a human-readable table.
- * Used by container list command.
- */
-export declare function formatContainerTable(containers: Container[], pagination: Pagination): void;
-/**
- * Format a container image list as a human-readable table.
- * Used by container-image list command.
- */
-export declare function formatContainerImageTable(images: ContainerImageListItem[], pagination: Pagination): void;
-/**
- * Format a container event list as a human-readable table.
- * Used by container events command.
- */
-export declare function formatContainerEventTable(events: ContainerEvent[], pagination: Pagination): void;
+export declare function formatCredentialsTable(credentials: Credentials[], pagination: Pagination): void;
+export declare function formatPoliciesTable(policies: CredentialsPolicy[], pagination: Pagination): void;
 /**
  * Format job steps as a human-readable table.
  * Used by job get command.

package/dist/lib/output.js

@@ -313,151 +313,85 @@ export function formatTriggerTable(triggers, pagination) {
         console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} triggers`));
     }
 }
-/**
- * Format a container list as a human-readable table.
- * Used by container list command.
- */
-export function formatContainerTable(containers, pagination) {
-    if (containers.length === 0) {
-        console.log(chalk.dim('No containers found'));
+export function formatCredentialsTable(credentials, pagination) {
+    if (credentials.length === 0) {
+        console.log(chalk.dim('No credentials found'));
         return;
     }
     const table = new Table({
         columns: [
             { name: 'id', title: 'ID', alignment: 'left' },
-            { name: 'status', title: 'STATUS', alignment: 'left' },
-            { name: 'image', title: 'IMAGE', alignment: 'left' },
-            { name: 'tag', title: 'TAG', alignment: 'left' },
+            { name: 'integration', title: 'INTEGRATION', alignment: 'left' },
+            { name: 'creator', title: 'CREATOR', alignment: 'left', color: 'cyan' },
             { name: 'created', title: 'CREATED', alignment: 'left' },
         ],
     });
-    containers.forEach((container) => {
-        const statusColor = container.status === 'RUNNING'
-            ? chalk.green
-            : container.status === 'ERRORED'
-                ? chalk.red
-                : container.status === 'DESTROYED'
-                    ? chalk.dim
-                    : chalk.yellow;
+    credentials.forEach((cred) => {
         table.addRow({
-            id: container.id,
-            status: statusColor(container.status),
-            image: container.image?.name || '-',
-            tag: container.image?.tag || '-',
-            created: container.created_at ? formatRelativeTime(container.created_at) : '',
+            id: cred.id,
+            integration: cred.integration.full_name,
+            creator: cred.creator.name,
+            created: formatRelativeTime(cred.created_at),
         });
     });
     table.printTable();
-    const showing = Math.min(pagination.limit, containers.length);
+    const showing = Math.min(pagination.limit, credentials.length);
     if (pagination.has_more) {
         const nextOffset = pagination.offset + pagination.limit;
-        console.log(`\nShowing ${showing} of ${pagination.total_count} containers. ` +
+        console.log(`\nShowing ${showing} of ${pagination.total_count} credentials. ` +
             chalk.dim(`Use --offset ${nextOffset} to see more.`));
     }
     else if (pagination.total_count > showing) {
-        console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} containers`));
+        console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} credentials`));
     }
 }
-/**
- * Format a container image list as a human-readable table.
- * Used by container-image list command.
- */
-export function formatContainerImageTable(images, pagination) {
-    if (images.length === 0) {
-        console.log(chalk.dim('No container images found'));
+export function formatPoliciesTable(policies, pagination) {
+    if (policies.length === 0) {
+        console.log(chalk.dim('No policies found'));
         return;
     }
     const table = new Table({
         columns: [
             { name: 'id', title: 'ID', alignment: 'left' },
-            { name: 'name', title: 'NAME', alignment: 'left' },
-            { name: 'image', title: 'IMAGE', alignment: 'left' },
-            { name: 'tag', title: 'TAG', alignment: 'left' },
-            { name: 'public', title: 'PUBLIC', alignment: 'left' },
-        ],
-    });
-    images.forEach((image) => {
-        table.addRow({
-            id: image.id,
-            name: image.name,
-            image: image.image_name,
-            tag: image.tag,
-            public: image.is_public ? chalk.green('yes') : chalk.dim('no'),
-        });
-    });
-    table.printTable();
-    const showing = Math.min(pagination.limit, images.length);
-    if (pagination.has_more) {
-        const nextOffset = pagination.offset + pagination.limit;
-        console.log(`\nShowing ${showing} of ${pagination.total_count} images. ` +
-            chalk.dim(`Use --offset ${nextOffset} to see more.`));
-    }
-    else if (pagination.total_count > showing) {
-        console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} images`));
-    }
-}
-/**
- * Derive a human-readable event type label from entity_type.
- */
-function formatEventType(entityType) {
-    if (entityType === 'EntContainerEventCreate')
-        return 'create';
-    if (entityType === 'EntContainerEventDestroy')
-        return 'destroy';
-    if (entityType === 'EntContainerEventCommand')
-        return 'command';
-    return entityType;
-}
-/**
- * Format a container event list as a human-readable table.
- * Used by container events command.
- */
-export function formatContainerEventTable(events, pagination) {
-    if (events.length === 0) {
-        console.log(chalk.dim('No events found'));
-        return;
-    }
-    const table = new Table({
-        columns: [
-            { name: 'id', title: 'ID', alignment: 'left' },
-            { name: 'type', title: 'TYPE', alignment: 'left', color: 'cyan' },
-            { name: 'status', title: 'STATUS', alignment: 'left' },
-            { name: 'actor', title: 'ACTOR', alignment: 'left' },
-            { name: 'detail', title: 'DETAIL', alignment: 'left' },
+            { name: 'decision', title: 'DECISION', alignment: 'left' },
+            { name: 'operations', title: 'OPERATIONS', alignment: 'left' },
+            { name: 'workspaces', title: 'WORKSPACES', alignment: 'left' },
+            { name: 'agents', title: 'AGENTS', alignment: 'left' },
+            { name: 'resources', title: 'RESOURCES', alignment: 'left' },
             { name: 'created', title: 'CREATED', alignment: 'left' },
         ],
     });
-    events.forEach((event) => {
-        const statusColor = event.status === 'SUCCESS'
-            ? chalk.green
-            : event.status === 'ERROR'
-                ? chalk.red
-                : chalk.yellow;
-        let detail = '';
-        if (event.entity_type === 'EntContainerEventCommand') {
-            detail = truncate(event.command, 30);
-        }
-        else if (event.status === 'ERROR' && event.error) {
-            detail = truncate(event.error, 30);
-        }
+    policies.forEach((policy) => {
+        const decisionColor = policy.decision === 'ALLOW' ? chalk.green : chalk.red;
         table.addRow({
-            id: event.id,
-            type: formatEventType(event.entity_type),
-            status: statusColor(event.status),
-            actor: event.actor?.name || event.actor?.full_name || '-',
-            detail,
-            created: event.created_at ? formatRelativeTime(event.created_at) : '',
+            id: policy.id,
+            decision: decisionColor(policy.decision),
+            operations: policy.operations
+                ? truncate(policy.operations.join(', '), 30)
+                : chalk.dim('all'),
+            workspaces: policy.workspaces.length > 0
+                ? truncate(policy.workspaces.map((w) => w.full_name || w.name).join(', '), 20)
+                : chalk.dim('all'),
+            agents: policy.agents.length > 0
+                ? truncate(policy.agents.map((a) => a.full_name || a.name).join(', '), 20)
+                : chalk.dim('all'),
+            resources: policy.resources
+                ? truncate(Object.entries(policy.resources)
+                    .map(([k, v]) => `${k}: ${v.join(', ')}`)
+                    .join('; '), 30)
+                : chalk.dim('none'),
+            created: formatRelativeTime(policy.created_at),
         });
     });
     table.printTable();
-    const showing = Math.min(pagination.limit, events.length);
+    const showing = Math.min(pagination.limit, policies.length);
     if (pagination.has_more) {
         const nextOffset = pagination.offset + pagination.limit;
-        console.log(`\nShowing ${showing} of ${pagination.total_count} events. ` +
+        console.log(`\nShowing ${showing} of ${pagination.total_count} policies. ` +
             chalk.dim(`Use --offset ${nextOffset} to see more.`));
     }
     else if (pagination.total_count > showing) {
-        console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} events`));
+        console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} policies`));
     }
 }
 /**

package/dist/lib/stdin.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Check if stdin is connected to an interactive terminal (TTY).
+ */
+export declare function isInteractive(): boolean;
 /**
  * Exit with a helpful error when stdin is piped but no --mode flag was given.
  * Call this before rendering an interactive UI (Ink render()) so users who

package/dist/lib/stdin.js

@@ -1,5 +1,11 @@
 // Copyright 2026 Guild.ai
 // SPDX-License-Identifier: Apache-2.0
+/**
+ * Check if stdin is connected to an interactive terminal (TTY).
+ */
+export function isInteractive() {
+    return process.stdin.isTTY === true;
+}
 /**
  * Exit with a helpful error when stdin is piped but no --mode flag was given.
  * Call this before rendering an interactive UI (Ink render()) so users who

package/dist/mcp/tools.js

@@ -694,7 +694,7 @@ export function registerTools(server, apiClient, defaultWorkspaceId, debug) {
                 const agent = t.agent.full_name || t.agent.name;
                 const disabled = t.deactivated_at ? ' [DISABLED]' : '';
                 if (t.type === 'webhook') {
-                    return `• ${t.id} [webhook] ${t.service}/${t.event_type || '*'} → ${agent}${disabled}`;
+                    return `• ${t.id} [webhook] ${t.integration.name}/${t.event_type || '*'} → ${agent}${disabled}`;
                 }
                 return `• ${t.id} [time] ${t.frequency} → ${agent}${disabled}`;
             })

package/docs/CLI_WORKFLOW.md

@@ -21,8 +21,9 @@ Use the **CLI** (via Bash) for **local development operations**: `guild agent in
 # Create a new agent
 guild agent init --name my-agent --template LLM
 
-# Clone an existing agent
+# Clone an existing agent (full name or short name)
 guild agent clone guildai/dev-assistant
+guild agent clone dev-assistant  # resolves to your-username/dev-assistant
 cd dev-assistant
 
 # Save changes (pushes commits to Guild server)
@@ -75,8 +76,9 @@ guild agent init --name my-agent --template BLANK
 # Fork an existing agent
 guild agent init --fork owner/agent-name
 
-# Clone to work on an existing agent
+# Clone to work on an existing agent (full name, short name, or UUID)
 guild agent clone owner/agent-name
+guild agent clone agent-name  # auto-resolves owner
 ```
 
 ### Working with Existing Agents