@guildai/cli 0.5.10 → 0.5.12

package/dist/index.js

@@ -11,7 +11,6 @@ import { createAuthLogoutCommand } from './commands/auth/logout.js';
 import { createAuthStatusCommand } from './commands/auth/status.js';
 import { createAuthTokenCommand } from './commands/auth/token.js';
 import { createAgentListCommand } from './commands/agent/list.js';
-import { createAgentCreateCommand } from './commands/agent/create.js';
 import { createAgentGetCommand } from './commands/agent/get.js';
 import { createAgentUpdateCommand } from './commands/agent/update.js';
 import { createAgentVersionsCommand } from './commands/agent/versions.js';
@@ -60,6 +59,16 @@ import { createSessionEventsCommand } from './commands/session/events.js';
 import { createSessionTasksCommand } from './commands/session/tasks.js';
 import { createSessionCreateCommand } from './commands/session/create.js';
 import { createSessionSendCommand } from './commands/session/send.js';
+import { createContainerGetCommand } from './commands/container/get.js';
+import { createContainerListCommand } from './commands/container/list.js';
+import { createContainerEventsCommand } from './commands/container/events.js';
+import { createContainerExecCommand } from './commands/container/exec.js';
+import { createContainerDestroyCommand } from './commands/container/destroy.js';
+import { createContainerImageListCommand } from './commands/container-image/list.js';
+import { createContainerImageGetCommand } from './commands/container-image/get.js';
+import { createContainerImageCreateCommand } from './commands/container-image/create.js';
+import { createJobGetCommand } from './commands/job/get.js';
+import { createJobStepGetCommand } from './commands/job/step-get.js';
 import { createConfigListCommand } from './commands/config/list.js';
 import { createConfigGetCommand } from './commands/config/get.js';
 import { createConfigSetCommand } from './commands/config/set.js';
@@ -70,6 +79,7 @@ import { createMcpCommand } from './commands/mcp.js';
 import { showSplashScreen, shouldShowSplash } from './lib/splash.js';
 import { checkForUpdate } from './lib/update-check.js';
 import { setupUnknownCommandSuggestions } from './lib/did-you-mean.js';
+import { getEnabledGKs, isGKEnabled } from './lib/gk.js';
 import chalk from 'chalk';
 // ESM equivalent of __dirname
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -122,7 +132,6 @@ authCmd.addCommand(createAuthTokenCommand());
 // Agent command group
 const agentCmd = program.command('agent').description('Agent management');
 agentCmd.addCommand(createAgentListCommand());
-agentCmd.addCommand(createAgentCreateCommand());
 agentCmd.addCommand(createAgentGetCommand());
 agentCmd.addCommand(createAgentUpdateCommand());
 agentCmd.addCommand(createAgentVersionsCommand());
@@ -208,6 +217,24 @@ triggerCmd.addCommand(createTriggerUpdateCommand());
 triggerCmd.addCommand(createTriggerActivateCommand());
 triggerCmd.addCommand(createTriggerDeactivateCommand());
 triggerCmd.addCommand(createTriggerSessionsCommand());
+// GK-gated commands: fetch enabled GKs and conditionally register command groups
+const enabledGKs = await getEnabledGKs();
+if (isGKEnabled('CONTAINERS', enabledGKs)) {
+    // Container command group
+    const containerCmd = program.command('container').description('Container management');
+    containerCmd.addCommand(createContainerListCommand());
+    containerCmd.addCommand(createContainerGetCommand());
+    containerCmd.addCommand(createContainerEventsCommand());
+    containerCmd.addCommand(createContainerExecCommand());
+    containerCmd.addCommand(createContainerDestroyCommand());
+    // Container image command group
+    const containerImageCmd = program
+        .command('container-image')
+        .description('Container image management');
+    containerImageCmd.addCommand(createContainerImageCreateCommand());
+    containerImageCmd.addCommand(createContainerImageListCommand());
+    containerImageCmd.addCommand(createContainerImageGetCommand());
+}
 // Session command group
 const sessionCmd = program.command('session').description('Session management');
 sessionCmd.addCommand(createSessionListCommand());
@@ -216,6 +243,10 @@ sessionCmd.addCommand(createSessionEventsCommand());
 sessionCmd.addCommand(createSessionTasksCommand());
 sessionCmd.addCommand(createSessionCreateCommand());
 sessionCmd.addCommand(createSessionSendCommand());
+// Job command group
+const jobCmd = program.command('job').description('Job management');
+jobCmd.addCommand(createJobGetCommand());
+jobCmd.addCommand(createJobStepGetCommand());
 // Config command group
 const configCmd = program
     .command('config')

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

@@ -315,6 +315,141 @@ 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 {
+    id: string;
+    session_type: 'chat' | 'agent_test' | 'time' | 'webhook';
+    name?: string;
+    workspace?: {
+        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 {
+    id: string;
+    name: string;
+    image_name: string;
+    tag: string;
+    is_public: boolean;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * The actor that created the container (user or task agent).
+ */
+export interface ContainerActor {
+    id: string;
+    entity_type: string;
+    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;
+    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';
+/**
+ * Job entity from the API.
+ * Used by: job get
+ */
+export interface Job {
+    id: string;
+    target_id: string;
+    job_type: JobType;
+    status: JobStatus;
+    started_at: string | null;
+    completed_at: string | null;
+    error_message: string | null;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Job step entity from the API.
+ * Used by: job get (steps table)
+ */
+export interface JobStep {
+    id: string;
+    job: Job;
+    name: string;
+    status: JobStepStatus;
+    started_at: string | null;
+    completed_at: string | null;
+    content: string | null;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Response from GET /jobs/:id/steps.
+ */
+export interface JobStepsResponse {
+    job_id: string;
+    steps: JobStep[];
+}
 /**
  * Contents of guild.json file in agent directories.
  */

package/dist/lib/auth.d.ts

@@ -50,7 +50,7 @@ export declare function showBetaGuidance(): void;
  * @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): Promise<boolean>;
+export declare function login(returnUrl?: string, returnLabel?: string, noBrowser?: boolean): Promise<boolean>;
 /**
  * Perform logout
  */

package/dist/lib/auth.js

@@ -196,36 +196,42 @@ export function showBetaGuidance() {
  * @param returnLabel - Optional friendly label for return button (e.g., "VSCode")
  * @returns true if successful, false otherwise
  */
-export async function login(returnUrl, returnLabel) {
+export async function login(returnUrl, returnLabel, noBrowser) {
     const authUrl = getGuildcoreUrl();
     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);
-        // 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
-        const { openBrowser } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'openBrowser',
-                message: 'Press Enter to open browser in your default web browser...',
-                default: true,
-            },
-        ]);
-        if (!openBrowser) {
-            console.error(chalk.red('✗ Authentication cancelled by user'));
-            return false;
+        const skipBrowser = noBrowser || process.stdin.isTTY !== true;
+        if (skipBrowser) {
+            console.log(chalk.dim('Open the URL above in your browser to complete authentication.'));
         }
-        // Open URL in default browser after user confirmation
-        try {
-            const open = (await import('open')).default;
-            await open(deviceCode.verification_uri_complete);
-        }
-        catch {
-            // Fallback if open fails - user can manually open URL
-            console.log(chalk.red('✗ Could not open browser automatically. Please visit the URL manually.\n'));
+        else {
+            // 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
+            const { openBrowser } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'openBrowser',
+                    message: 'Press Enter to open browser in your default web browser...',
+                    default: true,
+                },
+            ]);
+            if (!openBrowser) {
+                console.error(chalk.red('✗ Authentication cancelled by user'));
+                return false;
+            }
+            // Open URL in default browser after user confirmation
+            try {
+                const open = (await import('open')).default;
+                await open(deviceCode.verification_uri_complete);
+            }
+            catch {
+                // Fallback if open fails - user can manually open URL
+                console.log(chalk.red('✗ Could not open browser automatically. Please visit the URL manually.\n'));
+            }
         }
         const token = await pollForToken(authUrl, deviceCode.device_code, deviceCode.interval);
         if (token) {

package/dist/lib/config.js

@@ -46,10 +46,6 @@ export const IAP_CLIENT_ID = SHARED_IAP_CONFIG.clientId;
 export const IAP_SERVICE_ACCOUNT = SHARED_IAP_CONFIG.serviceAccount;
 /**
  * GuildCore URL constants
- *
- * TODO: Consider implementing proper feature flags (GK) for the CLI instead of
- * these hardcoded shortcuts. For now, --shared and --local are undocumented
- * developer conveniences.
  */
 const PROD_GUILDCORE_URL = 'https://app.guild.ai/api';
 const SHARED_GUILDCORE_URL = 'https://shared.guildai.dev/api';

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

@@ -1,5 +1,5 @@
-export declare const WEBHOOK_SERVICES: readonly ["AZURE_DEVOPS", "BITBUCKET", "CYPRESS", "GITHUB", "GOOGLE_DOCS", "GOOGLE_COMPUTE", "GOOGLE_LOGGING", "JIRA", "LINEAR", "NEWRELIC", "NOTION", "SLACK", "TESTRAIL", "ZENDESK"];
+export declare const WEBHOOK_SERVICES: readonly ["AZURE_DEVOPS", "BITBUCKET", "CURL", "CYPRESS", "GITHUB", "GOOGLE_DOCS", "GOOGLE_COMPUTE", "GOOGLE_LOGGING", "JIRA", "LINEAR", "NEWRELIC", "NOTION", "SLACK", "TESTRAIL", "ZENDESK"];
 export type WebhookService = (typeof WEBHOOK_SERVICES)[number];
-export declare const TIME_TRIGGER_FREQUENCIES: readonly ["HOURLY", "DAILY", "WEEKLY", "MONTHLY"];
+export declare const TIME_TRIGGER_FREQUENCIES: readonly ["HOURLY", "DAILY", "WEEKLY", "MONTHLY", "CRON"];
 export type TimeTriggerFrequency = (typeof TIME_TRIGGER_FREQUENCIES)[number];
 //# sourceMappingURL=generated-types.d.ts.map

package/dist/lib/generated-types.js

@@ -10,6 +10,7 @@
 export const WEBHOOK_SERVICES = [
     'AZURE_DEVOPS',
     'BITBUCKET',
+    'CURL',
     'CYPRESS',
     'GITHUB',
     'GOOGLE_DOCS',
@@ -29,5 +30,6 @@ export const TIME_TRIGGER_FREQUENCIES = [
     'DAILY',
     'WEEKLY',
     'MONTHLY',
+    'CRON',
 ];
 //# sourceMappingURL=generated-types.js.map

package/dist/lib/gk.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Fetch the set of GK names enabled for the current user.
+ *
+ * Returns null when the enabled set cannot be determined (not authenticated,
+ * network error, etc.). Callers should treat null as "show everything" (fail-open).
+ */
+export declare function getEnabledGKs(): Promise<Set<string> | null>;
+/**
+ * Check whether a specific GK is enabled for the current user.
+ *
+ * When enabledGKs is null (could not be determined), returns true (fail-open)
+ * so that commands are not hidden due to transient errors.
+ */
+export declare function isGKEnabled(gk: string, enabledGKs: Set<string> | null): boolean;
+//# sourceMappingURL=gk.d.ts.map

package/dist/lib/gk.js

@@ -0,0 +1,91 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import axios from 'axios';
+import { getGlobalConfigDir } from './guild-config.js';
+import { getGuildcoreUrl } from './config.js';
+import { getAuthToken } from './auth.js';
+import { getIapHeaders } from './iap.js';
+import { debug } from './errors.js';
+const GK_CACHE_FILE = 'gk-cache.json';
+const GK_CACHE_TTL_MS = 5 * 60 * 1000;
+function getCachePath() {
+    return path.join(getGlobalConfigDir(), GK_CACHE_FILE);
+}
+async function readCache(host) {
+    try {
+        const content = await fs.readFile(getCachePath(), 'utf-8');
+        const entry = JSON.parse(content);
+        if (entry.host === host && Date.now() - entry.ts < GK_CACHE_TTL_MS) {
+            debug('GK cache hit for %s', host);
+            return entry.gks;
+        }
+        debug('GK cache stale or host mismatch');
+    }
+    catch {
+        debug('GK cache not found or unreadable');
+    }
+    return null;
+}
+async function writeCache(host, gks) {
+    const configDir = getGlobalConfigDir();
+    await fs.mkdir(configDir, { recursive: true });
+    await fs.writeFile(getCachePath(), JSON.stringify({ gks, ts: Date.now(), host }));
+}
+/**
+ * Fetch the set of GK names enabled for the current user.
+ *
+ * Returns null when the enabled set cannot be determined (not authenticated,
+ * network error, etc.). Callers should treat null as "show everything" (fail-open).
+ */
+export async function getEnabledGKs() {
+    const token = await getAuthToken();
+    if (!token) {
+        debug('Not authenticated, skipping GK fetch');
+        return null;
+    }
+    const baseUrl = getGuildcoreUrl();
+    let host;
+    try {
+        host = new URL(baseUrl).host;
+    }
+    catch {
+        return null;
+    }
+    const cached = await readCache(host);
+    if (cached) {
+        return new Set(cached);
+    }
+    try {
+        const iapHeaders = await getIapHeaders(baseUrl);
+        const response = await axios.get(`${baseUrl}/gks/enabled`, {
+            headers: {
+                ...iapHeaders,
+                Authorization: `Bearer ${token}`,
+                Accept: 'application/json',
+            },
+            timeout: 5000,
+        });
+        const gkNames = response.data.gks.map((g) => g.name);
+        await writeCache(host, gkNames);
+        debug('Fetched %d enabled GKs', gkNames.length);
+        return new Set(gkNames);
+    }
+    catch (error) {
+        debug('Failed to fetch GKs: %s', error);
+        return null;
+    }
+}
+/**
+ * Check whether a specific GK is enabled for the current user.
+ *
+ * When enabledGKs is null (could not be determined), returns true (fail-open)
+ * so that commands are not hidden due to transient errors.
+ */
+export function isGKEnabled(gk, enabledGKs) {
+    if (!enabledGKs)
+        return true;
+    return enabledGKs.has(gk);
+}
+//# sourceMappingURL=gk.js.map

package/dist/lib/output.d.ts

@@ -1,19 +1,5 @@
 import { type Spinner } from './progress.js';
-import type { Agent, AgentVersion, Context, Pagination, Workspace, WorkspaceAgent, Trigger } from './api-types.js';
-/**
- * Session type from API responses
- */
-interface Session {
-    id: string;
-    session_type: 'chat' | 'agent_test' | 'time' | 'webhook';
-    name?: string;
-    workspace?: {
-        id: string;
-        name: string;
-    };
-    created_at: string;
-    updated_at: string;
-}
+import type { Agent, AgentVersion, Container, ContainerEvent, ContainerImageListItem, 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.
@@ -49,6 +35,26 @@ 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;
+/**
+ * Format job steps as a human-readable table.
+ * Used by job get command.
+ */
+export declare function formatJobStepTable(steps: JobStep[]): void;
 /**
  * Output writer interface for consistent CLI output
  *
@@ -108,5 +114,4 @@ export declare class JSONOutputWriter implements OutputWriter {
  * Create output writer based on current mode
  */
 export declare function createOutputWriter(): OutputWriter;
-export {};
 //# sourceMappingURL=output.d.ts.map