@agentuity/cli 1.0.22 → 1.0.23

package/src/cmd/cloud/webhook/list.ts

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createWebhookAPIClient, getWebhookApiOptions } from './util';
+import { getCommand } from '../../../command-prefix';
+import { listWebhooks, type Webhook } from '@agentuity/server';
+
+const WebhookListResponseSchema = z.object({
+	webhooks: z.array(
+		z.object({
+			name: z.string(),
+			id: z.string(),
+			description: z.string().nullable().optional(),
+			created_at: z.string(),
+		})
+	),
+});
+
+export const listSubcommand = createCommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List all webhooks',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{ command: getCommand('cloud webhook list'), description: 'List all webhooks' },
+		{ command: getCommand('cloud webhook ls'), description: 'List all webhooks (alias)' },
+	],
+	schema: {
+		args: z.object({}),
+		options: z.object({
+			orgId: z.string().optional().describe('Filter by organization ID'),
+			limit: z.coerce
+				.number()
+				.min(0)
+				.optional()
+				.describe('Maximum number of webhooks to return'),
+			offset: z.coerce.number().min(0).optional().describe('Offset for pagination'),
+		}),
+		response: WebhookListResponseSchema,
+	},
+	idempotent: true,
+
+	async handler(ctx) {
+		const { options, opts } = ctx;
+		const client = await createWebhookAPIClient(ctx);
+		const webhookOptions = opts?.orgId ? { orgId: opts.orgId } : getWebhookApiOptions(ctx);
+		const result = await listWebhooks(
+			client,
+			{
+				limit: opts.limit,
+				offset: opts.offset,
+			},
+			webhookOptions
+		);
+
+		if (!options.json) {
+			if (result.webhooks.length === 0) {
+				tui.info('No webhooks found');
+			} else {
+				const tableData = result.webhooks.map((w: Webhook) => ({
+					Name: w.name,
+					ID: w.id,
+					Description: w.description ?? '-',
+					Created: new Date(w.created_at).toLocaleString(),
+				}));
+				tui.table(tableData, ['Name', 'ID', 'Description', 'Created']);
+			}
+		}
+
+		return {
+			webhooks: result.webhooks.map((w: Webhook) => ({
+				name: w.name,
+				id: w.id,
+				description: w.description,
+				created_at: w.created_at,
+			})),
+		};
+	},
+});
+
+export default listSubcommand;

package/src/cmd/cloud/webhook/receipts.ts

@@ -0,0 +1,157 @@
+import { z } from 'zod';
+import { createCommand, createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createWebhookAPIClient, getWebhookApiOptions } from './util';
+import { getCommand } from '../../../command-prefix';
+import {
+	listWebhookReceipts,
+	getWebhookReceipt,
+	WebhookReceiptSchema,
+	type WebhookReceipt,
+} from '@agentuity/server';
+
+const ReceiptsListResponseSchema = z.object({
+	receipts: z.array(
+		z.object({
+			id: z.string(),
+			date: z.string(),
+			webhook_id: z.string(),
+		})
+	),
+});
+
+const listReceiptsSubcommand = createSubcommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List receipts for a webhook',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud webhook receipts list wh_abc123'),
+			description: 'List webhook receipts',
+		},
+	],
+	schema: {
+		args: z.object({
+			webhook_id: z.string().min(1).describe('Webhook ID'),
+		}),
+		options: z.object({
+			limit: z.coerce
+				.number()
+				.min(0)
+				.optional()
+				.describe('Maximum number of receipts to return'),
+			offset: z.coerce.number().min(0).optional().describe('Offset for pagination'),
+		}),
+		response: ReceiptsListResponseSchema,
+	},
+	idempotent: true,
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const client = await createWebhookAPIClient(ctx);
+		const result = await listWebhookReceipts(
+			client,
+			args.webhook_id,
+			{
+				limit: opts.limit,
+				offset: opts.offset,
+			},
+			getWebhookApiOptions(ctx)
+		);
+
+		if (!options.json) {
+			if (result.receipts.length === 0) {
+				tui.info('No receipts found');
+			} else {
+				const tableData = result.receipts.map((r: WebhookReceipt) => ({
+					ID: r.id,
+					Date: new Date(r.date).toLocaleString(),
+					'Webhook ID': r.webhook_id,
+				}));
+				tui.table(tableData, ['ID', 'Date', 'Webhook ID']);
+			}
+		}
+
+		return {
+			receipts: result.receipts.map((r: WebhookReceipt) => ({
+				id: r.id,
+				date: r.date,
+				webhook_id: r.webhook_id,
+			})),
+		};
+	},
+});
+
+const getReceiptSubcommand = createSubcommand({
+	name: 'get',
+	description: 'Get receipt details',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud webhook receipts get wh_abc123 whrc_def456'),
+			description: 'Get receipt details',
+		},
+	],
+	schema: {
+		args: z.object({
+			webhook_id: z.string().min(1).describe('Webhook ID'),
+			receipt_id: z.string().min(1).describe('Receipt ID'),
+		}),
+		response: WebhookReceiptSchema,
+	},
+	idempotent: true,
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const client = await createWebhookAPIClient(ctx);
+		const receipt = await getWebhookReceipt(
+			client,
+			args.webhook_id,
+			args.receipt_id,
+			getWebhookApiOptions(ctx)
+		);
+
+		if (!options.json) {
+			const details: Record<string, unknown> = {
+				ID: receipt.id,
+				Date: new Date(receipt.date).toLocaleString(),
+				'Webhook ID': receipt.webhook_id,
+			};
+
+			tui.table([details], undefined, { layout: 'vertical' });
+
+			tui.newline();
+			tui.info('Headers');
+			tui.json(receipt.headers);
+
+			tui.newline();
+			tui.info('Payload');
+			tui.json(receipt.payload);
+		}
+
+		return receipt;
+	},
+});
+
+export const receiptsSubcommand = createCommand({
+	name: 'receipts',
+	description: 'Manage webhook receipts',
+	tags: ['requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud webhook receipts list wh_abc123'),
+			description: 'List receipts',
+		},
+		{
+			command: getCommand('cloud webhook receipts get wh_abc123 whrc_def456'),
+			description: 'Get receipt details',
+		},
+	],
+	subcommands: [listReceiptsSubcommand, getReceiptSubcommand],
+});
+
+export default receiptsSubcommand;

package/src/cmd/cloud/webhook/util.ts

@@ -0,0 +1,35 @@
+import type { Logger } from '@agentuity/core';
+import { APIClient, type WebhookApiOptions } from '@agentuity/server';
+import { getGlobalCatalystAPIClient } from '../../../config';
+import type { AuthData, Config, GlobalOptions } from '../../../types';
+
+/**
+ * Context required for webhook API operations.
+ */
+export interface WebhookContext {
+	logger: Logger;
+	auth: AuthData;
+	config: Config | null;
+	options: GlobalOptions;
+	orgId?: string;
+}
+
+/**
+ * Creates an API client for webhook operations.
+ *
+ * Webhooks are global resources that don't require a project context.
+ * Uses the global Catalyst API client with user authentication.
+ */
+export async function createWebhookAPIClient(ctx: WebhookContext): Promise<APIClient> {
+	return getGlobalCatalystAPIClient(ctx.logger, ctx.auth, ctx.config?.name);
+}
+
+/**
+ * Creates WebhookApiOptions from the CLI context.
+ * Prioritizes explicit orgId on context, then falls back to global --org-id option,
+ * and finally to the preferred org from the profile configuration.
+ */
+export function getWebhookApiOptions(ctx: WebhookContext): WebhookApiOptions | undefined {
+	const orgId = ctx.orgId ?? ctx.options.orgId ?? ctx.config?.preferences?.orgId;
+	return orgId ? { orgId } : undefined;
+}

package/src/types.ts

@@ -1,13 +1,14 @@
 import type { Logger } from '@agentuity/core';
 import {
 	DeploymentConfig,
+	ProjectBuildConfig,
 	BuildMetadataSchema as ServerBuildMetadataSchema,
 } from '@agentuity/server';
 import type * as z from 'zod';
 import { z as zod } from 'zod';
 import type { APIClient } from './api';
 
-export { DeploymentConfig };
+export { DeploymentConfig, ProjectBuildConfig };
 
 export type { Logger };
 
@@ -720,6 +721,7 @@ export const ProjectSchema = zod.object({
 	orgId: zod.string().describe('the organization id'),
 	region: zod.string().describe('the region identifier that the project is deployed into'),
 	deployment: DeploymentConfig.optional().describe('the deployment configuration'),
+	build: ProjectBuildConfig.optional().describe('the CI/CD build configuration'),
 	skipGitSetup: zod
 		.boolean()
 		.optional()

package/src/version-check.ts

@@ -215,10 +215,29 @@ async function performUpgrade(logger: Logger, targetVersion: string): Promise<vo
 		// Exit with the same exit code as the new process
 		process.exit(proc.exitCode ?? 0);
 	} catch (error) {
-		// Upgrade failed - log and continue with original command
-		logger.error('Upgrade failed: %s', error instanceof Error ? error.message : 'Unknown error');
+		const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+		logger.error('Upgrade failed: %s', errorMessage);
+
+		// Check for known bun package manager bug (oven-sh/bun#18354)
+		if (errorMessage.includes('BadPathName')) {
+			tui.newline();
+			tui.warning(
+				'This appears to be a known bun package manager issue with stale global packages.'
+			);
+			tui.info('To fix this, run one of the following:');
+			tui.newline();
+			tui.info(`  ${tui.bold('Option 1:')} Clear stale packages and reinstall`);
+			tui.info(`  ${tui.muted('$')} rm -rf ~/.bun/install/global`);
+			tui.info(`  ${tui.muted('$')} bun add -g @agentuity/cli@latest`);
+			tui.newline();
+			tui.info(`  ${tui.bold('Option 2:')} Use the install script`);
+			tui.info(`  ${tui.muted('$')} curl -fsSL https://agentuity.sh | sh`);
+			tui.newline();
+		}
+
 		tui.warning('Continuing with current version...');
-		tui.info('');
+		tui.info('You can upgrade later by running: agentuity upgrade');
+		tui.newline();
 	}
 }