@guildai/cli 0.5.11 → 0.5.12

package/dist/commands/auth/login.js

@@ -11,9 +11,11 @@ export function createAuthLoginCommand() {
         .description('Login to Guild.ai')
         .option('--return-url <url>', 'Custom URL to redirect to after authentication')
         .option('--return-label <text>', 'Friendly label for return button (e.g., "VSCode")')
+        .option('--no-browser', 'Skip opening the browser (print URL only)')
         .action(async (options) => {
         const output = createOutputWriter();
-        const success = await login(options.returnUrl, options.returnLabel);
+        const noBrowser = options.browser === false;
+        const success = await login(options.returnUrl, options.returnLabel, noBrowser);
         if (success) {
             try {
                 await configureNpmrc();

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';
@@ -80,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));
@@ -132,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());
@@ -218,20 +217,24 @@ triggerCmd.addCommand(createTriggerUpdateCommand());
 triggerCmd.addCommand(createTriggerActivateCommand());
 triggerCmd.addCommand(createTriggerDeactivateCommand());
 triggerCmd.addCommand(createTriggerSessionsCommand());
-// 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());
+// 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());

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,4 +1,4 @@
-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", "CRON"];
 export type TimeTriggerFrequency = (typeof TIME_TRIGGER_FREQUENCIES)[number];

package/dist/lib/generated-types.js

@@ -10,6 +10,7 @@
 export const WEBHOOK_SERVICES = [
     'AZURE_DEVOPS',
     'BITBUCKET',
+    'CURL',
     'CYPRESS',
     'GITHUB',
     'GOOGLE_DOCS',

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/docs/CLI_WORKFLOW.md

@@ -11,7 +11,7 @@ For local agent development using the Guild CLI. This workflow manages agent cod
 
 If Guild MCP tools are available (check for tools prefixed with `guild_`), use them for **read operations**: searching agents, listing workspaces, reading contexts, checking sessions, viewing credentials. MCP tools are faster and don't require shell execution.
 
-Use the **CLI** (via Bash) for **local development operations**: `guild agent create`, `guild agent save`, `guild agent test`, `guild agent pull`, `guild agent clone`. These involve the local filesystem and git, which MCP can't do.
+Use the **CLI** (via Bash) for **local development operations**: `guild agent init`, `guild agent save`, `guild agent test`, `guild agent pull`, `guild agent clone`. These involve the local filesystem and git, which MCP can't do.
 
 ## CRITICAL: Always Use the Guild CLI
 
@@ -19,7 +19,7 @@ Use the **CLI** (via Bash) for **local development operations**: `guild agent cr
 
 ```bash
 # Create a new agent
-guild agent create my-agent --template LLM
+guild agent init --name my-agent --template LLM
 
 # Clone an existing agent
 guild agent clone guildai/dev-assistant
@@ -66,11 +66,11 @@ guild setup --claude-md
 ### Creating Agents
 
 ```bash
-# Create with template (interactive — prompts for template if omitted)
-guild agent create my-agent
-guild agent create my-agent --template LLM
-guild agent create my-agent --template AUTO_MANAGED_STATE
-guild agent create my-agent --template BLANK
+# Create and initialize a new agent (interactive — prompts for name and template)
+guild agent init
+guild agent init --name my-agent --template LLM
+guild agent init --name my-agent --template AUTO_MANAGED_STATE
+guild agent init --name my-agent --template BLANK
 
 # Fork an existing agent
 guild agent init --fork owner/agent-name
@@ -145,7 +145,7 @@ guild agent chat "Hello, can you help me?"
 
 ## File Structure
 
-After `guild agent create`, you get:
+After `guild agent init`, you get:
 
 ```
 my-agent/
@@ -175,7 +175,7 @@ Working tree is clean and there are no unpushed commits. Make a code change, com
 You're not in an agent directory. Either:
 
 - `cd` into the agent directory
-- Run `guild agent create` to create one
+- Run `guild agent init` to create one
 
 ### Validation Failed
 

package/docs/skills/agent-dev.md

@@ -11,7 +11,7 @@ Build agents for Guild using the CLI. **Always use the Guild CLI for agent opera
 
 If Guild MCP tools are available (check for tools prefixed with `guild_`), use them for **read operations**: searching agents, listing workspaces, reading contexts, checking sessions, viewing credentials. MCP tools are faster and don't require shell execution.
 
-Use the **CLI** (via Bash) for **local development operations**: `guild agent create`, `guild agent save`, `guild agent test`, `guild agent pull`, `guild agent clone`. These involve the local filesystem and git, which MCP can't do.
+Use the **CLI** (via Bash) for **local development operations**: `guild agent init`, `guild agent save`, `guild agent test`, `guild agent pull`, `guild agent clone`. These involve the local filesystem and git, which MCP can't do.
 
 ## When to Use This
 
@@ -39,17 +39,14 @@ guild setup --claude-md
 ### Creating Agents
 
 ```bash
-# Create from template (interactive - prompts for template)
-guild agent create my-agent
-
-# Create with specific template
-guild agent create my-agent --template LLM
-guild agent create my-agent --template AUTO_MANAGED_STATE
-guild agent create my-agent --template BLANK
-
-# Initialize local workspace for existing agent
+# Create and initialize a new agent (interactive - prompts for name and template)
 guild agent init
 
+# Create with specific name and template
+guild agent init --name my-agent --template LLM
+guild agent init --name my-agent --template AUTO_MANAGED_STATE
+guild agent init --name my-agent --template BLANK
+
 # Initialize with fork of existing agent
 guild agent init --fork owner/agent-name
 
@@ -98,7 +95,7 @@ guild agent chat "Hello, can you help me?"
 
 ### For Creating and Modifying
 
-- ✅ `guild agent create`, `guild agent init`, `guild agent clone`
+- ✅ `guild agent init`, `guild agent clone`
 - ✅ `git add`, `git commit` (manage your own working tree)
 - ✅ `guild agent save` (push commits and create a version)
 - ✅ `guild agent save -A --message "desc"` (stage+commit+push in one step)
@@ -1681,7 +1678,7 @@ export default agent({ run: async (input, task) => { ... } })
 
 ## File Structure
 
-After `guild agent create` + `guild agent init`:
+After `guild agent init`:
 
 ```
 my-agent/
@@ -1705,9 +1702,8 @@ my-agent/
 ```bash
 guild setup                                        # Install coding assistant skills
 guild setup --claude-md                            # Also create CLAUDE.md template
-guild agent create <name>                          # Create new agent (prompts for template)
-guild agent create <name> --template LLM           # Create with specific template
-guild agent init                                   # Initialize local workspace
+guild agent init                                   # Create and initialize a new agent
+guild agent init --name <name> --template LLM      # Create with specific name and template
 guild agent init --fork <agent-id>                 # Fork existing agent
 guild agent pull                                   # Pull remote changes
 guild agent save                                   # Push commits and create a draft version

package/package.json

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

package/dist/commands/agent/create.d.ts

@@ -1,3 +0,0 @@
-import { Command } from 'commander';
-export declare function createAgentCreateCommand(): Command;
-//# sourceMappingURL=create.d.ts.map

package/dist/commands/agent/create.js

@@ -1,132 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-import { Command } from 'commander';
-import inquirer from 'inquirer';
-import { GuildAPIClient } from '../../lib/api-client.js';
-import { getGuildcoreUrl } from '../../lib/config.js';
-import { handleAxiosError, ErrorCodes } from '../../lib/errors.js';
-import { pollAgentStatus } from '../../lib/polling.js';
-import { createOutputWriter } from '../../lib/output.js';
-const TEMPLATE_CHOICES = [
-    {
-        name: 'LLM - Simple language model agent (recommended)',
-        value: 'LLM',
-        short: 'LLM',
-    },
-    {
-        name: 'Auto-managed state - Agent with automatic state management',
-        value: 'AUTO_MANAGED_STATE',
-        short: 'Auto-managed state',
-    },
-    {
-        name: 'Blank - Start from scratch',
-        value: 'BLANK',
-        short: 'Blank',
-    },
-];
-function isInteractive() {
-    return process.stdin.isTTY === true;
-}
-async function promptForTemplate() {
-    const { template } = await inquirer.prompt([
-        {
-            type: 'list',
-            name: 'template',
-            message: 'Select agent template:',
-            choices: TEMPLATE_CHOICES,
-            default: 'LLM',
-        },
-    ]);
-    return template;
-}
-export function createAgentCreateCommand() {
-    const cmd = new Command('create');
-    cmd
-        .description('Create a new agent')
-        .argument('<name>', 'Agent name')
-        .option('--description <text>', 'Agent description')
-        .option('--owner-id <id>', 'Owner ID (user or organization, defaults to current user)')
-        .option('--template <template>', 'Agent template (LLM, AUTO_MANAGED_STATE, BLANK)')
-        .option('--no-wait', 'Return immediately without waiting for initialization')
-        .action(async (name, options) => {
-        const output = createOutputWriter();
-        const baseUrl = getGuildcoreUrl();
-        const client = new GuildAPIClient({ baseUrl });
-        try {
-            // Get owner_id: use --owner-id option or default to current user
-            let ownerId = options.ownerId;
-            if (!ownerId) {
-                const me = (await client.get('/me'));
-                ownerId = me.id;
-            }
-            // Determine template: use --template option, prompt if interactive, or error
-            let template = options.template;
-            if (!template) {
-                if (isInteractive()) {
-                    template = await promptForTemplate();
-                }
-                else {
-                    output.error('Error: --template is required in non-interactive mode', `Provide a template:\n  guild agent create ${name} --template LLM\n\nAvailable templates:\n  • LLM - Simple language model agent (recommended)\n  • AUTO_MANAGED_STATE - Agent with automatic state management\n  • BLANK - Start from scratch`);
-                    process.exit(1);
-                }
-            }
-            // Normalize template to uppercase for case-insensitive matching
-            template = template.toUpperCase();
-            // Validate template
-            const validTemplates = [
-                'LLM',
-                'AUTO_MANAGED_STATE',
-                'BLANK',
-            ];
-            if (!validTemplates.includes(template)) {
-                output.error(`Error: Invalid template '${template}'`, 'Valid templates:\n  • LLM\n  • AUTO_MANAGED_STATE\n  • BLANK');
-                process.exit(1);
-            }
-            const response = await client.post('/agents', {
-                name,
-                owner_id: ownerId,
-                description: options.description || 'No description provided',
-                template,
-            });
-            // By default, poll until agent is ready (unless --no-wait is passed)
-            if (options.wait !== false) {
-                const pollResult = await pollAgentStatus(response.id, 'READY');
-                if (pollResult.success && pollResult.response) {
-                    // Display the updated response with READY status
-                    output.data(pollResult.response);
-                }
-                else {
-                    // Polling failed or timed out - this is an error
-                    output.error('Agent initialization failed or timed out', `Check status: guild agent get ${response.id}`);
-                    output.data(response);
-                    process.exit(1);
-                }
-            }
-            else {
-                // --no-wait: return immediately without polling
-                output.data(response);
-            }
-        }
-        catch (error) {
-            const formattedError = handleAxiosError(error);
-            // Provide specific error messages based on error code
-            if (formattedError.code === ErrorCodes.AUTH_REQUIRED) {
-                output.error('Not logged in.', 'Please authenticate first:\n  guild auth login');
-            }
-            else if (formattedError.code === ErrorCodes.CONN_REFUSED) {
-                output.error('Cannot connect to Guild servers');
-            }
-            else if (formattedError.code === ErrorCodes.API_ERROR &&
-                formattedError.details.includes('already exists')) {
-                output.error(`Agent name '${name}' already exists.`, `Try a different name:\n  guild agent create ${name}-v2`);
-            }
-            else {
-                // Generic error with details from server
-                output.error(`Failed to create agent: ${formattedError.details}`);
-            }
-            process.exit(1);
-        }
-    });
-    return cmd;
-}
-//# sourceMappingURL=create.js.map