@agentuity/cli 1.0.22 → 1.0.23

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

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createWebhookAPIClient, getWebhookApiOptions } from './util';
+import { getCommand } from '../../../command-prefix';
+import { createWebhook, WebhookSchema } from '@agentuity/server';
+
+const WebhookCreateResponseSchema = WebhookSchema.pick({ id: true, name: true, url: true, created_at: true });
+
+export const createSubcommand = createCommand({
+	name: 'create',
+	description: 'Create a new webhook',
+	tags: ['mutating', 'creates-resource', 'requires-auth'],
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('cloud webhook create --name my-webhook'),
+			description: 'Create a webhook named my-webhook',
+		},
+		{
+			command: getCommand(
+				'cloud webhook create --name github-events --description "GitHub webhook"'
+			),
+			description: 'Create a webhook with a description',
+		},
+	],
+	schema: {
+		args: z.object({}),
+		options: z.object({
+			name: z.string().describe('Webhook name'),
+			description: z.string().optional().describe('Webhook description'),
+		}),
+		response: WebhookCreateResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { opts, options } = ctx;
+		const client = await createWebhookAPIClient(ctx);
+
+		const webhook = await createWebhook(
+			client,
+			{
+				name: opts.name,
+				description: opts.description,
+			},
+			getWebhookApiOptions(ctx)
+		);
+
+		if (!options.json) {
+			tui.success(`Created webhook: ${webhook.name}`);
+			console.log(`  ID:  ${webhook.id}`);
+			if (webhook.url) {
+				console.log(`  URL: ${webhook.url}`);
+			}
+		}
+
+		return {
+			id: webhook.id,
+			name: webhook.name,
+			url: webhook.url,
+			created_at: webhook.created_at,
+		};
+	},
+});
+
+export default createSubcommand;

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

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createWebhookAPIClient, getWebhookApiOptions } from './util';
+import { getCommand } from '../../../command-prefix';
+import { deleteWebhook } from '@agentuity/server';
+import { ErrorCode } from '../../../errors';
+
+const DeleteResponseSchema = z.object({
+	success: z.boolean(),
+	id: z.string(),
+});
+
+export const deleteSubcommand = createCommand({
+	name: 'delete',
+	aliases: ['rm'],
+	description: 'Delete a webhook by ID',
+	tags: ['mutating', 'deletes-resource', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud webhook delete wh_abc123 --confirm'),
+			description: 'Delete a webhook (requires confirmation)',
+		},
+	],
+	schema: {
+		args: z.object({
+			id: z.string().min(1).describe('Webhook ID'),
+		}),
+		options: z.object({
+			confirm: z.boolean().default(false).describe('Skip confirmation prompt'),
+		}),
+		response: DeleteResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+
+		if (!opts.confirm) {
+			tui.fatal('Use --confirm to confirm webhook deletion', ErrorCode.INVALID_ARGUMENT);
+		}
+
+		const client = await createWebhookAPIClient(ctx);
+		await deleteWebhook(client, args.id, getWebhookApiOptions(ctx));
+
+		if (!options.json) {
+			tui.success(`Deleted webhook: ${args.id}`);
+		}
+
+		return {
+			success: true,
+			id: args.id,
+		};
+	},
+});
+
+export default deleteSubcommand;

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

@@ -0,0 +1,149 @@
+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 {
+	listWebhookDeliveries,
+	retryWebhookDelivery,
+	WebhookDeliverySchema,
+	type WebhookDelivery,
+} from '@agentuity/server';
+
+const DeliveriesListResponseSchema = z.object({
+	deliveries: z.array(
+		z.object({
+			id: z.string(),
+			date: z.string(),
+			status: z.string(),
+			retries: z.number(),
+			webhook_destination_id: z.string(),
+		})
+	),
+});
+
+const listDeliveriesSubcommand = createSubcommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List deliveries for a webhook',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud webhook deliveries list wh_abc123'),
+			description: 'List webhook deliveries',
+		},
+	],
+	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 deliveries to return'),
+			offset: z.coerce.number().min(0).optional().describe('Offset for pagination'),
+		}),
+		response: DeliveriesListResponseSchema,
+	},
+	idempotent: true,
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const client = await createWebhookAPIClient(ctx);
+		const result = await listWebhookDeliveries(
+			client,
+			args.webhook_id,
+			{
+				limit: opts.limit,
+				offset: opts.offset,
+			},
+			getWebhookApiOptions(ctx)
+		);
+
+		if (!options.json) {
+			if (result.deliveries.length === 0) {
+				tui.info('No deliveries found');
+			} else {
+				const tableData = result.deliveries.map((d: WebhookDelivery) => ({
+					ID: d.id,
+					Date: new Date(d.date).toLocaleString(),
+					Status: d.status,
+					Retries: d.retries,
+					'Destination ID': d.webhook_destination_id,
+				}));
+				tui.table(tableData, ['ID', 'Date', 'Status', 'Retries', 'Destination ID']);
+			}
+		}
+
+		return {
+			deliveries: result.deliveries.map((d: WebhookDelivery) => ({
+				id: d.id,
+				date: d.date,
+				status: d.status,
+				retries: d.retries,
+				webhook_destination_id: d.webhook_destination_id,
+			})),
+		};
+	},
+});
+
+const retryDeliverySubcommand = createSubcommand({
+	name: 'retry',
+	description: 'Retry a failed webhook delivery',
+	tags: ['mutating', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud webhook deliveries retry wh_abc123 whdv_def456'),
+			description: 'Retry a failed delivery',
+		},
+	],
+	schema: {
+		args: z.object({
+			webhook_id: z.string().min(1).describe('Webhook ID'),
+			delivery_id: z.string().min(1).describe('Delivery ID'),
+		}),
+		response: WebhookDeliverySchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const client = await createWebhookAPIClient(ctx);
+		const delivery = await retryWebhookDelivery(
+			client,
+			args.webhook_id,
+			args.delivery_id,
+			getWebhookApiOptions(ctx)
+		);
+
+		if (!options.json) {
+			tui.success(`Retried delivery: ${delivery.id}`);
+			console.log(`  Status: ${delivery.status}`);
+		}
+
+		return delivery;
+	},
+});
+
+export const deliveriesSubcommand = createCommand({
+	name: 'deliveries',
+	description: 'Manage webhook deliveries',
+	tags: ['requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud webhook deliveries list wh_abc123'),
+			description: 'List deliveries',
+		},
+		{
+			command: getCommand('cloud webhook deliveries retry wh_abc123 whdv_def456'),
+			description: 'Retry a failed delivery',
+		},
+	],
+	subcommands: [listDeliveriesSubcommand, retryDeliverySubcommand],
+});
+
+export default deliveriesSubcommand;

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

@@ -0,0 +1,274 @@
+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 { ErrorCode } from '../../../errors';
+import {
+	createWebhookDestination,
+	listWebhookDestinations,
+	updateWebhookDestination,
+	deleteWebhookDestination,
+	WebhookDestinationSchema,
+	type WebhookDestination,
+} from '@agentuity/server';
+
+const DestinationsListResponseSchema = z.object({
+	destinations: z.array(
+		z.object({
+			id: z.string(),
+			type: z.string(),
+			config: z.record(z.string(), z.unknown()),
+			created_at: z.string(),
+		})
+	),
+});
+
+const listDestinationsSubcommand = createSubcommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List destinations for a webhook',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud webhook destinations list wh_abc123'),
+			description: 'List webhook destinations',
+		},
+	],
+	schema: {
+		args: z.object({
+			webhook_id: z.string().min(1).describe('Webhook ID'),
+		}),
+		response: DestinationsListResponseSchema,
+	},
+	idempotent: true,
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const client = await createWebhookAPIClient(ctx);
+		const destinations = await listWebhookDestinations(
+			client,
+			args.webhook_id,
+			getWebhookApiOptions(ctx)
+		);
+
+		if (!options.json) {
+			if (destinations.length === 0) {
+				tui.info('No destinations configured');
+			} else {
+				const tableData = destinations.map((d: WebhookDestination) => ({
+					ID: d.id,
+					Type: d.type,
+					Config: JSON.stringify(d.config),
+					Created: new Date(d.created_at).toLocaleString(),
+				}));
+				tui.table(tableData, ['ID', 'Type', 'Config', 'Created']);
+			}
+		}
+
+		return {
+			destinations: destinations.map((d: WebhookDestination) => ({
+				id: d.id,
+				type: d.type,
+				config: d.config,
+				created_at: d.created_at,
+			})),
+		};
+	},
+});
+
+const createUrlDestinationSubcommand = createSubcommand({
+	name: 'url',
+	description: 'Create a URL destination for a webhook',
+	tags: ['mutating', 'creates-resource', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand(
+				'cloud webhook destinations create url wh_abc123 https://example.com/webhook'
+			),
+			description: 'Create a URL destination',
+		},
+	],
+	schema: {
+		args: z.object({
+			webhook_id: z.string().min(1).describe('Webhook ID'),
+			url: z.string().min(1).describe('Destination URL'),
+		}),
+		response: WebhookDestinationSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const client = await createWebhookAPIClient(ctx);
+
+		const destination = await createWebhookDestination(
+			client,
+			args.webhook_id,
+			{
+				type: 'url',
+				config: { url: args.url },
+			},
+			getWebhookApiOptions(ctx)
+		);
+
+		if (!options.json) {
+			tui.success(`Created destination: ${destination.id}`);
+			console.log(`  URL: ${args.url}`);
+		}
+
+		return destination;
+	},
+});
+
+const createDestinationSubcommand = createCommand({
+	name: 'create',
+	description: 'Create a destination for a webhook',
+	tags: ['mutating', 'creates-resource', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand(
+				'cloud webhook destinations create url wh_abc123 --url https://example.com/webhook'
+			),
+			description: 'Create a URL destination',
+		},
+	],
+	subcommands: [createUrlDestinationSubcommand],
+});
+
+const updateDestinationSubcommand = createSubcommand({
+	name: 'update',
+	description: 'Update a webhook destination',
+	tags: ['mutating', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand(
+				'cloud webhook destinations update wh_abc123 whds_def456 --url https://example.com/v2'
+			),
+			description: 'Update a destination URL',
+		},
+	],
+	schema: {
+		args: z.object({
+			webhook_id: z.string().min(1).describe('Webhook ID'),
+			destination_id: z.string().min(1).describe('Destination ID'),
+		}),
+		options: z.object({
+			url: z.string().optional().describe('Updated destination URL'),
+		}),
+		response: WebhookDestinationSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const client = await createWebhookAPIClient(ctx);
+
+		const updateParams: { config?: Record<string, unknown> } = {};
+
+		if (opts.url) {
+			updateParams.config = { url: opts.url };
+		}
+
+		const destination = await updateWebhookDestination(
+			client,
+			args.webhook_id,
+			args.destination_id,
+			updateParams,
+			getWebhookApiOptions(ctx)
+		);
+
+		if (!options.json) {
+			tui.success(`Updated destination: ${destination.id}`);
+			console.log(`  URL: ${JSON.stringify(destination.config)}`);
+		}
+
+		return destination;
+	},
+});
+
+const DeleteDestinationResponseSchema = z.object({
+	success: z.boolean(),
+	webhook_id: z.string(),
+	destination_id: z.string(),
+});
+
+const deleteDestinationSubcommand = createSubcommand({
+	name: 'delete',
+	aliases: ['rm'],
+	description: 'Delete a destination from a webhook',
+	tags: ['mutating', 'deletes-resource', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud webhook destinations delete wh_abc123 whds_def456 --confirm'),
+			description: 'Delete a destination',
+		},
+	],
+	schema: {
+		args: z.object({
+			webhook_id: z.string().min(1).describe('Webhook ID'),
+			destination_id: z.string().min(1).describe('Destination ID'),
+		}),
+		options: z.object({
+			confirm: z.boolean().default(false).describe('Skip confirmation prompt'),
+		}),
+		response: DeleteDestinationResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+
+		if (!opts.confirm) {
+			tui.fatal('Use --confirm to confirm destination deletion', ErrorCode.INVALID_ARGUMENT);
+		}
+
+		const client = await createWebhookAPIClient(ctx);
+		await deleteWebhookDestination(
+			client,
+			args.webhook_id,
+			args.destination_id,
+			getWebhookApiOptions(ctx)
+		);
+
+		if (!options.json) {
+			tui.success(`Deleted destination: ${args.destination_id}`);
+		}
+
+		return {
+			success: true,
+			webhook_id: args.webhook_id,
+			destination_id: args.destination_id,
+		};
+	},
+});
+
+export const destinationsSubcommand = createCommand({
+	name: 'destinations',
+	aliases: ['dest'],
+	description: 'Manage webhook destinations',
+	tags: ['requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud webhook destinations list wh_abc123'),
+			description: 'List destinations',
+		},
+		{
+			command: getCommand(
+				'cloud webhook destinations create url wh_abc123 --url https://example.com/webhook'
+			),
+			description: 'Create a URL destination',
+		},
+	],
+	subcommands: [
+		listDestinationsSubcommand,
+		createDestinationSubcommand,
+		updateDestinationSubcommand,
+		deleteDestinationSubcommand,
+	],
+});
+
+export default destinationsSubcommand;

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

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createWebhookAPIClient, getWebhookApiOptions } from './util';
+import { getCommand } from '../../../command-prefix';
+import { getWebhook, WebhookSchema } from '@agentuity/server';
+
+export const getSubcommand = createCommand({
+	name: 'get',
+	description: 'Get webhook details',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud webhook get wh_abc123'),
+			description: 'Get webhook details',
+		},
+	],
+	schema: {
+		args: z.object({
+			id: z.string().min(1).describe('Webhook ID'),
+		}),
+		response: WebhookSchema,
+	},
+	idempotent: true,
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const client = await createWebhookAPIClient(ctx);
+		const apiOptions = getWebhookApiOptions(ctx);
+
+		const webhook = await getWebhook(client, args.id, apiOptions);
+
+		if (!options.json) {
+			const details: Record<string, unknown> = {
+				Name: webhook.name,
+				ID: webhook.id,
+			};
+
+			if (webhook.description) {
+				details.Description = webhook.description;
+			}
+
+			if (webhook.url) {
+				details.URL = webhook.url;
+			}
+
+			details['Created By'] = webhook.created_by;
+			details.Created = new Date(webhook.created_at).toISOString();
+			details.Updated = new Date(webhook.updated_at).toISOString();
+
+			tui.table([details], undefined, { layout: 'vertical' });
+		}
+
+		return webhook;
+	},
+});
+
+export default getSubcommand;

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

@@ -0,0 +1,46 @@
+import { createCommand } from '../../../types';
+import { listSubcommand } from './list';
+import { createSubcommand } from './create';
+import { getSubcommand } from './get';
+import { deleteSubcommand } from './delete';
+import { destinationsSubcommand } from './destinations';
+import { receiptsSubcommand } from './receipts';
+import { deliveriesSubcommand } from './deliveries';
+import { getCommand } from '../../../command-prefix';
+
+export const command = createCommand({
+	name: 'webhook',
+	aliases: ['webhooks'],
+	description: 'Manage webhooks for receiving external HTTP callbacks',
+	tags: ['requires-auth'],
+	examples: [
+		{
+			command: getCommand('cloud webhook list'),
+			description: 'List all webhooks',
+		},
+		{
+			command: getCommand('cloud webhook create --name my-webhook'),
+			description: 'Create a webhook',
+		},
+		{
+			command: getCommand('cloud webhook get wh_abc123'),
+			description: 'Get webhook details',
+		},
+		{
+			command: getCommand('cloud webhook destinations list wh_abc123'),
+			description: 'List webhook destinations',
+		},
+	],
+	subcommands: [
+		listSubcommand,
+		createSubcommand,
+		getSubcommand,
+		deleteSubcommand,
+		destinationsSubcommand,
+		receiptsSubcommand,
+		deliveriesSubcommand,
+	],
+	requires: { auth: true },
+});
+
+export default command;