@guildai/cli 0.10.0 → 0.12.0

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

@@ -357,6 +357,50 @@ export interface Organization {
     viewer_role: 'ADMIN' | 'MEMBER' | null;
 }
 export type OrganizationListResponse = PaginatedResponse<Organization>;
+/**
+ * Skill entity from the API.
+ * Used by: skill list, skill get, skill create, skill update
+ */
+export interface Skill {
+    id: string;
+    entity_type: string;
+    type: 'skill';
+    full_name: string;
+    name: string;
+    overview: string;
+    is_public: boolean;
+    avatar_url: string | null;
+    owner: {
+        id: string;
+        name: string;
+        type: string;
+    };
+    viewer_can_edit: boolean;
+    created_at: string;
+    updated_at: string;
+    latest_version?: SkillVersion | null;
+}
+/**
+ * Skill version entity from the API.
+ * Used by: skill version list, skill version get, skill version create
+ */
+export interface SkillVersion {
+    id: string;
+    entity_type: string;
+    type: 'skill_version';
+    version_number: string;
+    description: string;
+    body?: string;
+    skill?: Skill;
+    author?: {
+        id: string;
+        name: string;
+    };
+    created_at: string;
+    updated_at: string;
+}
+export type SkillListResponse = PaginatedResponse<Skill>;
+export type SkillVersionListResponse = PaginatedResponse<SkillVersion>;
 export interface Credentials {
     id: string;
     integration: {

package/dist/lib/auth.d.ts

@@ -46,7 +46,7 @@ export declare function pollForToken(authUrl: string, code: string, interval: nu
  * @param returnLabel - Optional friendly label for return button (e.g., "VSCode")
  * @returns true if successful, false otherwise
  */
-export declare function login(returnUrl?: string, returnLabel?: string, nonInteractive?: boolean): Promise<boolean>;
+export declare function login(returnUrl?: string, returnLabel?: string): Promise<boolean>;
 /**
  * Perform logout
  */

package/dist/lib/config.d.ts

@@ -48,6 +48,15 @@ export declare function getGuildcoreUrl(): string;
  * Used to construct clickable links to dashboard pages.
  */
 export declare function getDashboardUrl(): string;
+/**
+ * Get the Guildcore WebSocket base URL
+ *
+ * Derives the WebSocket URL from the HTTP guildcore URL:
+ * - http:// → ws://, https:// → wss://
+ *
+ * @returns WebSocket base URL (e.g., "wss://app.guild.ai/api")
+ */
+export declare function getGuildcoreWsUrl(): string;
 /**
  * Check if the given URL is an IAP-protected host
  *

package/dist/lib/errors.d.ts

@@ -39,7 +39,7 @@ export declare const ErrorCodes: {
     readonly VALIDATION_ERROR: "VALIDATION_ERROR";
 };
 /**
- * Check if debug mode is enabled (CLI flag or config)
+ * Check if debug mode is enabled (CLI flag, config, or env var)
  */
 export declare function isDebugMode(): boolean;
 /**

package/dist/lib/output-mode.d.ts

@@ -1,11 +1,18 @@
-export type OutputMode = 'interactive' | 'json';
+export type OutputMode = 'interactive' | 'json' | 'jsonl';
 /**
  * Detect output mode from CLI flags or config
  *
- * Checks --json flag and config. CLI flag overrides config.
+ * Priority: --mode <value> > --json (backward compat) > config
  * Does NOT auto-detect pipes (user must request JSON explicitly).
  */
 export declare function getOutputMode(): OutputMode;
+/**
+ * Check if the current output mode is machine-readable (json or jsonl).
+ *
+ * Use this in list/get commands instead of `getOutputMode() === 'json'`
+ * so that both --mode json and --mode jsonl trigger non-interactive output.
+ */
+export declare function isMachineReadable(): boolean;
 /**
  * Check if quiet mode is enabled (CLI flag or config)
  *

package/dist/lib/output.d.ts

@@ -1,5 +1,5 @@
 import { type Spinner } from './progress.js';
-import type { Agent, AgentVersion, Credentials, CredentialsPolicy, Context, Integration, IntegrationVersion, JobStep, Pagination, Session, Task, Workspace, WorkspaceAgent, Trigger } from './api-types.js';
+import type { Agent, AgentVersion, Credentials, CredentialsPolicy, Context, Integration, IntegrationVersion, JobStep, Pagination, Session, Skill, SkillVersion, Task, ValidationStep, Workspace, WorkspaceAgent, Trigger } from './api-types.js';
 /**
  * Format an agent list as a human-readable table.
  * Shared by agent list and agent search commands.
@@ -10,6 +10,16 @@ export declare function formatAgentTable(agents: Agent[], pagination: Pagination
  * Used by integration list command.
  */
 export declare function formatIntegrationTable(integrations: Integration[], pagination: Pagination): void;
+/**
+ * Format a skill list as a human-readable table.
+ * Used by skill list command.
+ */
+export declare function formatSkillTable(skills: Skill[], pagination: Pagination): void;
+/**
+ * Format a skill version list as a human-readable table.
+ * Used by skill version list command.
+ */
+export declare function formatSkillVersionTable(versions: SkillVersion[], pagination: Pagination, skillName: string): void;
 /**
  * Format an integration version list as a human-readable table.
  * Used by integration version list command.
@@ -57,6 +67,12 @@ export declare function formatPoliciesTable(policies: CredentialsPolicy[], pagin
  * Used by job get command.
  */
 export declare function formatJobStepTable(steps: JobStep[]): void;
+/**
+ * Format validation step logs as human-readable output.
+ * Prints each step's name, colored status, and full log content.
+ * Used by the `guild agent logs` command.
+ */
+export declare function formatValidationLogs(steps: ValidationStep[]): void;
 /**
  * Output writer interface for consistent CLI output
  *

package/dist/lib/session-events.d.ts

@@ -4,7 +4,7 @@
  * These types match the backend event system from the messaging refactor (PR #819).
  * All CLI commands should import these types instead of defining their own.
  */
-export type TaskStatus = 'CREATED' | 'STARTED' | 'RUNNING' | 'WAITING' | 'DONE' | 'ERROR' | 'INTERRUPTED';
+export type TaskStatus = 'CREATED' | 'DISPATCHED' | 'STARTED' | 'RUNNING' | 'WAITING' | 'DONE' | 'ERROR' | 'INTERRUPTED';
 export interface BaseTaskFields {
     id: string;
     status: TaskStatus;
@@ -97,14 +97,23 @@ export interface TextContent {
     type: 'text';
     data: string;
 }
+export interface UnknownContent {
+    type: string;
+    data?: unknown;
+}
+export interface MultipartContent {
+    type: 'multipart/mixed';
+    parts: UnknownContent[];
+}
 export interface ResponseStreamContent {
     type: 'application/guild-response-stream';
     stream_id: string;
     sequence: number;
-    status: 'streaming' | 'done' | 'aborted';
+    status: 'streaming' | 'done' | 'continued' | 'aborted';
     text: string;
+    is_delta?: boolean;
 }
-export type AgentNotificationMessageContent = TextContent | ResponseStreamContent;
+export type AgentNotificationMessageContent = TextContent | MultipartContent | ResponseStreamContent;
 export interface AgentNotificationMessageEvent extends BaseEvent {
     type: 'agent_notification_message';
     content: AgentNotificationMessageContent;
@@ -181,6 +190,8 @@ export declare function isDoneResponseStreamEvent(event: SessionEvent): event is
         status: 'done';
     };
 };
+/** Apply a response-stream payload to the accumulated display text. */
+export declare function applyResponseStreamText(currentText: string, content: ResponseStreamContent): string;
 /** Extract display text from notification content. */
 export declare function getAgentNotificationText(event: AgentNotificationMessageEvent): string;
 /** Check if an event belongs to the root task or has no task context. */

package/dist/lib/session-polling.d.ts

@@ -1,11 +1,21 @@
 import { GuildAPIClient } from './api-client.js';
+import { SessionEvent } from './session-events.js';
 export interface PollResult {
     response: string | null;
     /** Last event ID seen — pass as `afterEventId` on next call. */
     lastEventId: string | undefined;
 }
+export interface PollOnceResult {
+    events: SessionEvent[];
+    lastEventId: string | undefined;
+    reason: 'completion' | 'error' | 'ui_prompt' | 'inactivity_timeout';
+}
 /**
- * Poll for agent response using from_id cursor.
+ * Poll for agent response using WebSocket streaming with HTTP fallback.
+ *
+ * Does one initial HTTP GET (using from_id cursor) to check if the response
+ * is already available, then opens a WebSocket for real-time events.
+ * Falls back to HTTP polling if the WebSocket connection fails.
  *
  * Handles both multi-turn agents (which emit agent_notification_message)
  * and one-shot agents (which may only emit runtime_done with output content).
@@ -23,6 +33,19 @@ export declare function pollForResponse(client: GuildAPIClient, sessionId: strin
  * Same completion logic as pollForResponse(), but writes each event that
  * passes the filter to stdout so callers get intermediate output (console.log,
  * progress, etc.) in JSON/JSONL automation modes.
+ *
+ * Uses HTTP polling (not WebSocket) since it needs to emit each event
+ * individually to stdout as JSONL.
  */
 export declare function pollForResponseWithEvents(client: GuildAPIClient, sessionId: string, eventFilter: Set<string>, afterEventId: string | undefined, maxWaitTime?: number): Promise<PollResult>;
+/**
+ * Poll for --once mode using WebSocket streaming with HTTP fallback.
+ *
+ * Accumulates all events (unlike pollForResponse which returns a single response)
+ * and checks for completion conditions after each batch.
+ */
+export declare function pollForOnce(client: GuildAPIClient, sessionId: string, options?: {
+    inactivityTimeoutMs?: number;
+    pollIntervalMs?: number;
+}): Promise<PollOnceResult>;
 //# sourceMappingURL=session-polling.d.ts.map

package/dist/lib/session-resume.d.ts

@@ -1,5 +1,5 @@
 import { GuildAPIClient } from './api-client.js';
-import { SessionEvent, Session } from './session-events.js';
+import { type ResponseStreamContent, SessionEvent, Session } from './session-events.js';
 /**
  * Print a dimmed resume hint to stderr on session exit.
  * Only call when a session ID is available.
@@ -19,6 +19,20 @@ export interface DisplayMessage {
     type: 'user' | 'assistant' | 'progress';
     timestamp?: string;
 }
+export interface ResponseStreamResumeState {
+    keys: Map<string, string>;
+    contents: Map<string, ResponseStreamContent[]>;
+    texts: Map<string, string>;
+    timestamps: Map<string, string>;
+    statuses: Map<string, ResponseStreamContent['status']>;
+    keysByTask: Map<string, Set<string>>;
+}
+export interface SessionResumeDisplay {
+    displayMessages: DisplayMessage[];
+    responseStreamState: ResponseStreamResumeState;
+}
+export declare function responseStreamResumeStateFromEvents(events: SessionEvent[]): ResponseStreamResumeState;
+export declare function prepareSessionResumeDisplay(events: SessionEvent[]): SessionResumeDisplay;
 /**
  * Convert session events to display messages for resume.
  * Maps user_message, agent_notification_message, and agent_notification_error

package/dist/lib/stdin.d.ts

@@ -1,5 +1,9 @@
 /**
- * Check if stdin is connected to an interactive terminal (TTY).
+ * Check if the CLI is running in interactive mode.
+ *
+ * Returns false when:
+ *  - stdin is not a TTY (piped input, CI, cron)
+ *  - the global --non-interactive flag is set
  */
 export declare function isInteractive(): boolean;
 /**

package/dist/lib/websocket-client.d.ts

@@ -0,0 +1,46 @@
+type WsState = 'connecting' | 'connected' | 'disconnected' | 'reconnecting';
+export interface WebSocketClientOptions<R> {
+    /** WebSocket endpoint path (e.g., "/sessions/{id}/events/ws") */
+    path: string;
+    /** Query parameters to append to the URL */
+    queryParams?: Record<string, string>;
+    /** Called for each received JSON message */
+    onMessage: (message: R) => void;
+    /** Called when the connection fails permanently (auth error, max retries) */
+    onError?: (error: Error) => void;
+    /** Returns the last seen ID for reconnection resume via from_id */
+    getFromId?: () => string | undefined;
+    /** Debug label for logging */
+    label: string;
+}
+/**
+ * Node.js WebSocket client for Guild backend endpoints.
+ *
+ * Handles auth headers (Bearer + IAP), auto-reconnect with exponential
+ * backoff + jitter, connection timeout, and from_id resume on reconnect.
+ */
+export declare class GuildWebSocketClient<R> {
+    private ws;
+    private state;
+    private readonly options;
+    private reconnectTimer;
+    private connectTimeout;
+    private reconnectAttempts;
+    private constructor();
+    /**
+     * Create and connect a WebSocket client.
+     * Rejects if initial connection or auth fails.
+     */
+    static create<R>(options: WebSocketClientOptions<R>): Promise<GuildWebSocketClient<R>>;
+    private buildUrl;
+    private getHeaders;
+    private cleanupSocket;
+    private connect;
+    private scheduleReconnect;
+    /** Close the connection cleanly. No reconnection will be attempted. */
+    close(): void;
+    /** Current connection state */
+    getState(): WsState;
+}
+export {};
+//# sourceMappingURL=websocket-client.d.ts.map

package/dist/open-RF4X5MOP.js

@@ -0,0 +1,13 @@
+import { createRequire as _cjsReq } from 'module'; if(typeof require === 'undefined') var require = _cjsReq(import.meta.url);
+import {
+  apps,
+  openApp,
+  open_default
+} from "./chunk-56YCMGL3.js";
+import "./chunk-OYQ476FQ.js";
+export {
+  apps,
+  open_default as default,
+  openApp
+};
+//# sourceMappingURL=open-RF4X5MOP.js.map

package/dist/open-RF4X5MOP.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}