@guildai/cli 0.5.13 → 0.6.1

package/dist/commands/integration/version/test.js

@@ -0,0 +1,104 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { GuildAPIClient } from '../../../lib/api-client.js';
+import { getAuthToken } from '../../../lib/auth.js';
+import { handleAxiosError } from '../../../lib/errors.js';
+import { getOutputMode } from '../../../lib/output-mode.js';
+import { createOutputWriter } from '../../../lib/output.js';
+import { resolveVersionId } from '../../../lib/integration-helpers.js';
+function parseJsonFlag(value, flagName) {
+    try {
+        return JSON.parse(value);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new Error(`Invalid JSON for ${flagName}: ${msg}`);
+    }
+}
+export function createIntegrationVersionTestCommand() {
+    const cmd = new Command('test');
+    cmd
+        .description('Test an endpoint invocation')
+        .argument('<id_or_name>', 'Integration ID or name (owner~name)')
+        .option('--version <semver>', 'Specific version, e.g. 1.0.0')
+        .requiredOption('--operation <name>', 'Operation to test, e.g. list_users')
+        .option('--account <name>', 'Account name to resolve credential from')
+        .option('--input-path <json>', 'JSON object of path parameters')
+        .option('--input-query <json>', 'JSON object of query parameters')
+        .option('--input-body <json>', 'JSON object for request body')
+        .action(async (identifier, options) => {
+        const output = createOutputWriter();
+        try {
+            const token = await getAuthToken();
+            if (!token) {
+                output.error('Not authenticated. Please log in first.', 'Run: guild auth login');
+                process.exit(1);
+            }
+            // Validate JSON inputs before any API calls
+            const body = {
+                operation: options.operation,
+            };
+            if (options.inputPath) {
+                body.input_path = parseJsonFlag(options.inputPath, '--input-path');
+            }
+            if (options.inputQuery) {
+                body.input_query = parseJsonFlag(options.inputQuery, '--input-query');
+            }
+            if (options.inputBody) {
+                body.input_body = parseJsonFlag(options.inputBody, '--input-body');
+            }
+            const client = new GuildAPIClient();
+            const versionId = await resolveVersionId(client, identifier, options.version);
+            if (options.account) {
+                const creds = await client.get(`/accounts/${options.account}/credentials?integration=${encodeURIComponent(identifier)}`);
+                if (creds.items.length === 0) {
+                    output.error(`Error: No credentials found for account '${options.account}' on integration '${identifier}'`);
+                    process.exit(1);
+                }
+                body.credential_id = creds.items[0].id;
+            }
+            const response = await client.post(`/integration_versions/${versionId}/test`, body);
+            if (getOutputMode() === 'json') {
+                output.data(response);
+            }
+            else {
+                console.log(`Testing operation: ${options.operation}`);
+                console.log();
+                console.log(chalk.bold('Request'));
+                console.log(`  ${'URL'.padEnd(9)}${response.request_url}`);
+                console.log();
+                console.log(chalk.bold('Response'));
+                console.log(`  ${'Status'.padEnd(9)}${response.status_code}`);
+                console.log(`  ${'Type'.padEnd(9)}${response.content_type || chalk.dim('—')}`);
+                console.log();
+                console.log(chalk.bold('Body'));
+                if (response.body !== null && response.body !== undefined) {
+                    const bodyStr = typeof response.body === 'string'
+                        ? response.body
+                        : JSON.stringify(response.body, null, 2);
+                    const indented = bodyStr
+                        .split('\n')
+                        .map((line) => `  ${line}`)
+                        .join('\n');
+                    console.log(indented);
+                }
+                else {
+                    console.log(chalk.dim('  (empty)'));
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.startsWith('Invalid JSON')) {
+                output.error(`Error: ${error.message}`);
+                process.exit(1);
+            }
+            const formattedError = handleAxiosError(error);
+            output.error(`Failed to test endpoint: ${formattedError.details}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=test.js.map

package/dist/commands/trigger/create.js

@@ -6,7 +6,7 @@ import { getAuthToken } from '../../lib/auth.js';
 import { getWorkspaceId } from '../../lib/guild-config.js';
 import { handleAxiosError, ErrorCodes } from '../../lib/errors.js';
 import { createOutputWriter } from '../../lib/output.js';
-import { WEBHOOK_SERVICES, TIME_TRIGGER_FREQUENCIES, } from '../../lib/api-types.js';
+import { TIME_TRIGGER_FREQUENCIES, } from '../../lib/api-types.js';
 export function createTriggerCreateCommand() {
     const cmd = new Command('create');
     cmd
@@ -15,7 +15,7 @@ export function createTriggerCreateCommand() {
         .requiredOption('--type <type>', 'Trigger type: webhook or time')
         .requiredOption('--agent <identifier>', 'Agent identifier (e.g., owner/agent-name)')
         // Webhook options
-        .option('--service <service>', 'Webhook service: GITHUB, BITBUCKET, JIRA, SLACK')
+        .option('--integration <name>', 'Integration name for webhook triggers (e.g., github, slack, jira)')
         .option('--event <event>', 'Event type (e.g., app_mention, issues)')
         .option('--action <action>', 'Event action (e.g., opened, created)')
         .option('--service-config <json>', 'Service-specific config as JSON')
@@ -29,17 +29,26 @@ export function createTriggerCreateCommand() {
         .action(async (options) => {
         const output = createOutputWriter();
         try {
-            const token = await getAuthToken();
-            if (!token) {
-                output.error('Not authenticated. Run: guild auth login');
-                process.exit(1);
-            }
-            // Validate trigger type
+            // Validate trigger type before auth (fail fast on bad input)
             const triggerType = options.type.toLowerCase();
             if (triggerType !== 'webhook' && triggerType !== 'time') {
                 output.error('--type must be "webhook" or "time"');
                 process.exit(1);
             }
+            // Validate type-specific required options before auth
+            if (triggerType === 'webhook' && !options.integration) {
+                output.error('--integration is required for webhook triggers (e.g., --integration github)');
+                process.exit(1);
+            }
+            if (triggerType === 'time' && !options.frequency) {
+                output.error(`--frequency is required for time triggers. Valid: ${TIME_TRIGGER_FREQUENCIES.join(', ')}`);
+                process.exit(1);
+            }
+            const token = await getAuthToken();
+            if (!token) {
+                output.error('Not authenticated. Run: guild auth login');
+                process.exit(1);
+            }
             // Resolve workspace
             let workspaceId = options.workspace;
             if (!workspaceId) {
@@ -63,20 +72,31 @@ export function createTriggerCreateCommand() {
             // Build request body based on trigger type
             let body;
             if (triggerType === 'webhook') {
-                // Validate webhook-specific options
-                if (!options.service) {
-                    output.error(`--service is required for webhook triggers. Valid: ${WEBHOOK_SERVICES.join(', ')}`);
+                // Fetch workspace details to get the owner account ID
+                const workspace = await client.get(`/workspaces/${workspaceId}`);
+                if (!workspace.owner) {
+                    output.error('Could not resolve workspace owner');
                     process.exit(1);
                 }
-                const service = options.service.toUpperCase();
-                if (!WEBHOOK_SERVICES.includes(service)) {
-                    output.error(`Invalid service "${options.service}". Valid: ${WEBHOOK_SERVICES.join(', ')}`);
+                // Fetch integrations with webhook configs for this account
+                const integrations = await client.fetchAll(`/accounts/${workspace.owner.id}/integrations?has_webhooks_only=true`);
+                // Match by integration name (case-insensitive)
+                const integrationName = options.integration.toLowerCase();
+                const integration = integrations.find((i) => i.name.toLowerCase() === integrationName ||
+                    i.full_name.toLowerCase() === integrationName);
+                if (!integration) {
+                    const available = integrations.map((i) => i.name).join(', ');
+                    output.error(`Integration "${options.integration}" not found.${available ? ` Available: ${available}` : ' No webhook integrations configured.'}`);
+                    process.exit(1);
+                }
+                if (!integration.webhook_config) {
+                    output.error(`Integration "${integration.name}" does not have webhooks configured`);
                     process.exit(1);
                 }
                 body = {
                     type: 'webhook',
-                    service: service,
                     workspace_agent_id: workspaceAgent.id,
+                    webhook_config_id: integration.webhook_config.id,
                 };
                 if (options.event) {
                     body.event_type = options.event;
@@ -96,10 +116,6 @@ export function createTriggerCreateCommand() {
             }
             else {
                 // Time trigger
-                if (!options.frequency) {
-                    output.error(`--frequency is required for time triggers. Valid: ${TIME_TRIGGER_FREQUENCIES.join(', ')}`);
-                    process.exit(1);
-                }
                 const frequency = options.frequency.toUpperCase();
                 if (!TIME_TRIGGER_FREQUENCIES.includes(frequency)) {
                     output.error(`Invalid frequency "${options.frequency}". Valid: ${TIME_TRIGGER_FREQUENCIES.join(', ')}`);

package/dist/commands/workspace/create.js

@@ -4,21 +4,27 @@ import { Command } from 'commander';
 import { GuildAPIClient } from '../../lib/api-client.js';
 import { handleAxiosError, ErrorCodes } from '../../lib/errors.js';
 import { createOutputWriter } from '../../lib/output.js';
+import { resolveOwnerId } from '../../lib/owner-helpers.js';
+import { isInteractive } from '../../lib/stdin.js';
 export function createWorkspaceCreateCommand() {
     const cmd = new Command('create');
     cmd
         .description('Create a new workspace')
         .argument('<name>', 'Workspace name')
-        .action(async (name) => {
+        .option('--owner <owner>', 'Owner (name or ID)')
+        .action(async (name, options) => {
         const output = createOutputWriter();
         try {
             const client = new GuildAPIClient();
-            // Get current user info to use as workspace owner
-            const me = (await client.get('/me'));
+            const owner = await resolveOwnerId({
+                ownerFlag: options.owner,
+                client,
+                interactive: isInteractive(),
+            });
             // Create workspace
             const workspace = await client.post('/workspaces', {
                 name,
-                owner_id: me.id,
+                owner_id: owner.id,
             });
             output.data(workspace);
         }

package/dist/commands/workspace/select.js

@@ -86,7 +86,6 @@ export function createWorkspaceSelectCommand() {
             const selectedId = await search({
                 message: 'Select a workspace (type to filter)',
                 pageSize: 15,
-                default: currentId,
                 source: (input) => {
                     const term = input?.toLowerCase() ?? '';
                     const filtered = term

package/dist/index.js

@@ -59,27 +59,37 @@ 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';
 import { createConfigPathCommand } from './commands/config/path.js';
+import { createCredentialsEndpointListCommand } from './commands/credentials/endpoint-list.js';
+import { createCredentialsListCommand } from './commands/credentials/list.js';
+import { createCredentialsPolicyCreateCommand } from './commands/credentials/policy-create.js';
+import { createCredentialsPolicyDeleteCommand } from './commands/credentials/policy-delete.js';
+import { createCredentialsPolicyListCommand } from './commands/credentials/policy-list.js';
+import { createCredentialsPolicyUpdateCommand } from './commands/credentials/policy-update.js';
 import { createDoctorCommand } from './commands/doctor.js';
 import { createSetupCommand } from './commands/setup.js';
 import { createMcpCommand } from './commands/mcp.js';
+import { createIntegrationListCommand } from './commands/integration/list.js';
+import { createIntegrationGetCommand } from './commands/integration/get.js';
+import { createIntegrationCreateCommand } from './commands/integration/create.js';
+import { createIntegrationUpdateCommand } from './commands/integration/update.js';
+import { createIntegrationConnectCommand } from './commands/integration/connect.js';
+import { createIntegrationVersionListCommand } from './commands/integration/version/list.js';
+import { createIntegrationVersionCreateCommand } from './commands/integration/version/create.js';
+import { createIntegrationVersionGetCommand } from './commands/integration/version/get.js';
+import { createIntegrationVersionBuildCommand } from './commands/integration/version/build.js';
+import { createIntegrationVersionPublishCommand } from './commands/integration/version/publish.js';
+import { createIntegrationVersionTestCommand } from './commands/integration/version/test.js';
+import { createIntegrationOperationListCommand } from './commands/integration/operation/list.js';
+import { createIntegrationOperationCreateCommand } from './commands/integration/operation/create.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));
@@ -156,6 +166,31 @@ tagsCmd.addCommand(createAgentTagsListCommand());
 tagsCmd.addCommand(createAgentTagsAddCommand());
 tagsCmd.addCommand(createAgentTagsRemoveCommand());
 tagsCmd.addCommand(createAgentTagsSetCommand());
+// Integration command group
+const integrationCmd = program
+    .command('integration')
+    .description('Manage integrations');
+integrationCmd.addCommand(createIntegrationListCommand());
+integrationCmd.addCommand(createIntegrationGetCommand());
+integrationCmd.addCommand(createIntegrationCreateCommand());
+integrationCmd.addCommand(createIntegrationUpdateCommand());
+integrationCmd.addCommand(createIntegrationConnectCommand());
+// Integration version subcommand group
+const integrationVersionCmd = integrationCmd
+    .command('version')
+    .description('Manage integration versions');
+integrationVersionCmd.addCommand(createIntegrationVersionListCommand());
+integrationVersionCmd.addCommand(createIntegrationVersionCreateCommand());
+integrationVersionCmd.addCommand(createIntegrationVersionGetCommand());
+integrationVersionCmd.addCommand(createIntegrationVersionBuildCommand());
+integrationVersionCmd.addCommand(createIntegrationVersionPublishCommand());
+integrationVersionCmd.addCommand(createIntegrationVersionTestCommand());
+// Integration operation subcommand group
+const integrationOperationCmd = integrationCmd
+    .command('operation')
+    .description('Manage version operations');
+integrationOperationCmd.addCommand(createIntegrationOperationListCommand());
+integrationOperationCmd.addCommand(createIntegrationOperationCreateCommand());
 // Workspace command group
 const workspaceCmd = program.command('workspace').description('Workspace management');
 workspaceCmd.addCommand(createWorkspaceListCommand());
@@ -217,24 +252,22 @@ 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());
-}
+// Credentials command group
+const credentialsCmd = program
+    .command('credentials')
+    .description('Credential management');
+credentialsCmd.addCommand(createCredentialsListCommand());
+const credentialsPolicyCmd = credentialsCmd
+    .command('policy')
+    .description('Manage credential policies');
+credentialsPolicyCmd.addCommand(createCredentialsPolicyListCommand());
+credentialsPolicyCmd.addCommand(createCredentialsPolicyCreateCommand());
+credentialsPolicyCmd.addCommand(createCredentialsPolicyUpdateCommand());
+credentialsPolicyCmd.addCommand(createCredentialsPolicyDeleteCommand());
+const credentialsEndpointCmd = credentialsCmd
+    .command('endpoint')
+    .description('Manage credential endpoints');
+credentialsEndpointCmd.addCommand(createCredentialsEndpointListCommand());
 // Session command group
 const sessionCmd = program.command('session').description('Session management');
 sessionCmd.addCommand(createSessionListCommand());

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,18 @@ export interface AgentVersionDetail {
         description: string;
     };
 }
+export interface TriggerIntegrationWebhookConfig {
+    id: string;
+    enabled: boolean;
+    events: Record<string, string[]>;
+}
+export interface TriggerIntegration {
+    id: string;
+    name: string;
+    full_name: string;
+    service?: string | null;
+    webhook_config: TriggerIntegrationWebhookConfig | 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 +251,6 @@ export interface TriggerWorkspaceAgent {
 export interface TriggerWebhook {
     id: string;
     type: 'webhook';
-    service: WebhookService;
     event_type: string | null;
     action: string | null;
     service_config?: {
@@ -248,6 +259,7 @@ export interface TriggerWebhook {
         project?: string;
         jql_filter?: string;
     } | Record<string, unknown>;
+    integration: TriggerIntegration;
     created_at: string;
     deactivated_at: string | null;
     disabled_reason: TriggerDisabledReason | null;
@@ -315,101 +327,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';
@@ -450,6 +416,71 @@ export interface JobStepsResponse {
     job_id: string;
     steps: JobStep[];
 }
+export interface IntegrationOwner {
+    id: string;
+    name: string;
+}
+export interface IntegrationAuthConfig {
+    id: string;
+    entity_type: string;
+    auth_scheme: 'API_KEY' | 'OAUTH';
+    token_header_template?: string;
+    install_url?: string;
+    token_url?: string;
+    client_id?: string;
+    scopes?: string[];
+}
+export interface IntegrationProtocolConfig {
+    protocol: 'REST';
+    base_url: string;
+}
+export interface IntegrationWebhookConfig {
+    enabled: boolean;
+    events?: string[];
+}
+export interface IntegrationPublishedVersion {
+    id: string;
+    version_number: string;
+    published_at: string;
+}
+export interface Integration {
+    id: string;
+    entity_type: string;
+    created_at: string;
+    updated_at: string;
+    name: string;
+    description: string | null;
+    is_public: boolean;
+    avatar_url: string | null;
+    owner: IntegrationOwner;
+    auth_config: IntegrationAuthConfig;
+    protocol_config: IntegrationProtocolConfig;
+    webhook_config: IntegrationWebhookConfig | null;
+    params: unknown[];
+    viewer_can_edit: boolean;
+    latest_published_version?: IntegrationPublishedVersion | null;
+}
+export type IntegrationListResponse = PaginatedResponse<Integration>;
+export interface IntegrationVersion {
+    id: string;
+    entity_type: string;
+    created_at: string;
+    updated_at: string;
+    author: {
+        id: string;
+        name: string;
+    };
+    validation_status: string;
+    published_at: string | null;
+    publishing_started_at: string | null;
+    version_number: string | null;
+    integration?: {
+        id: string;
+        name: string;
+        description: string;
+    };
+}
+export type IntegrationVersionListResponse = PaginatedResponse<IntegrationVersion>;
 /**
  * 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, noBrowser?: boolean): Promise<boolean>;
+export declare function login(returnUrl?: string, returnLabel?: string, nonInteractive?: boolean): Promise<boolean>;
 /**
  * Perform logout
  */