@agentuity/cli 0.1.16 → 0.1.17

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

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createQueueAPIClient, getQueueApiOptions } from './util';
+import { getCommand } from '../../../command-prefix';
+import { createQueue, QueueTypeSchema } from '@agentuity/server';
+
+const QueueCreateResponseSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	queue_type: z.string(),
+	created_at: z.string(),
+});
+
+export const createSubcommand = createCommand({
+	name: 'create',
+	description: 'Create a new queue',
+	tags: ['mutating', 'creates-resource', 'requires-auth'],
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('cloud queue create worker --name my-tasks'),
+			description: 'Create a worker queue named my-tasks',
+		},
+		{
+			command: getCommand('cloud queue create pubsub --name events --ttl 86400'),
+			description: 'Create a pubsub queue with 24h TTL',
+		},
+	],
+	schema: {
+		args: z.object({
+			queue_type: QueueTypeSchema.describe('Queue type: worker or pubsub'),
+		}),
+		options: z.object({
+			name: z.string().optional().describe('Queue name (auto-generated if not provided)'),
+			description: z.string().optional().describe('Queue description'),
+			ttl: z.coerce.number().optional().describe('Default message TTL in seconds'),
+			visibilityTimeout: z.coerce
+				.number()
+				.optional()
+				.describe('Default visibility timeout in seconds (worker queues)'),
+			maxRetries: z.coerce
+				.number()
+				.optional()
+				.describe('Maximum retry attempts for failed messages'),
+		}),
+		response: QueueCreateResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const client = await createQueueAPIClient(ctx);
+
+		const settings: Record<string, number | undefined> = {};
+		if (opts?.ttl !== undefined) {
+			settings.default_ttl_seconds = opts.ttl;
+		}
+		if (opts?.visibilityTimeout !== undefined) {
+			settings.default_visibility_timeout_seconds = opts.visibilityTimeout;
+		}
+		if (opts?.maxRetries !== undefined) {
+			settings.default_max_retries = opts.maxRetries;
+		}
+
+		const queue = await createQueue(
+			client,
+			{
+				name: opts?.name,
+				description: opts?.description,
+				queue_type: args.queue_type,
+				settings: Object.keys(settings).length > 0 ? settings : undefined,
+			},
+			getQueueApiOptions(ctx)
+		);
+
+		if (!options.json) {
+			tui.success(`Created queue: ${queue.name}`);
+			console.log(`  ID:   ${queue.id}`);
+			console.log(`  Type: ${queue.queue_type}`);
+		}
+
+		return {
+			id: queue.id,
+			name: queue.name,
+			queue_type: queue.queue_type,
+			created_at: queue.created_at,
+		};
+	},
+});
+
+export default createSubcommand;

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

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createQueueAPIClient, getQueueApiOptions } from './util';
+import { getCommand } from '../../../command-prefix';
+import { deleteQueue } from '@agentuity/server';
+import { ErrorCode } from '../../../errors';
+
+const DeleteResponseSchema = z.object({
+	success: z.boolean(),
+	name: z.string(),
+});
+
+export const deleteSubcommand = createCommand({
+	name: 'delete',
+	aliases: ['rm'],
+	description: 'Delete a queue by name',
+	tags: ['mutating', 'deletes-resource', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud queue delete my-queue --confirm'),
+			description: 'Delete a queue (requires confirmation)',
+		},
+	],
+	schema: {
+		args: z.object({
+			name: z.string().min(1).describe('Queue name'),
+		}),
+		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 queue deletion', ErrorCode.INVALID_ARGUMENT);
+		}
+
+		const client = await createQueueAPIClient(ctx);
+		await deleteQueue(client, args.name, getQueueApiOptions(ctx));
+
+		if (!options.json) {
+			tui.success(`Deleted queue: ${args.name}`);
+		}
+
+		return {
+			success: true,
+			name: args.name,
+		};
+	},
+});
+
+export default deleteSubcommand;

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

@@ -0,0 +1,287 @@
+import { z } from 'zod';
+import { createCommand, createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createQueueAPIClient, getQueueApiOptions } from './util';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+import {
+	createDestination,
+	listDestinations,
+	updateDestination,
+	deleteDestination,
+	DestinationSchema,
+	DestinationAlreadyExistsError,
+	type Destination,
+} from '@agentuity/server';
+
+const DestinationsListResponseSchema = z.object({
+	destinations: z.array(
+		z.object({
+			id: z.string(),
+			destination_type: z.string(),
+			url: z.string(),
+			enabled: z.boolean(),
+			created_at: z.string(),
+		})
+	),
+});
+
+const listDestinationsSubcommand = createSubcommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List destinations for a queue',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud queue destinations list my-queue'),
+			description: 'List queue destinations',
+		},
+	],
+	schema: {
+		args: z.object({
+			queue_name: z.string().min(1).describe('Queue name'),
+		}),
+		response: DestinationsListResponseSchema,
+	},
+	idempotent: true,
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const client = await createQueueAPIClient(ctx);
+		const destinations = await listDestinations(client, args.queue_name, getQueueApiOptions(ctx));
+
+		if (!options.json) {
+			if (destinations.length === 0) {
+				tui.info('No destinations configured');
+			} else {
+				const tableData = destinations.map((d: Destination) => ({
+					ID: d.id,
+					Type: d.destination_type,
+					URL: d.config.url,
+					Enabled: d.enabled ? 'Yes' : 'No',
+					Created: new Date(d.created_at).toLocaleString(),
+				}));
+				tui.table(tableData, ['ID', 'Type', 'URL', 'Enabled', 'Created']);
+			}
+		}
+
+		return {
+			destinations: destinations.map((d: Destination) => ({
+				id: d.id,
+				destination_type: d.destination_type,
+				url: d.config.url,
+				enabled: d.enabled,
+				created_at: d.created_at,
+			})),
+		};
+	},
+});
+
+const createDestinationSubcommand = createSubcommand({
+	name: 'create',
+	description: 'Create a webhook destination for a queue',
+	tags: ['mutating', 'creates-resource', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand(
+				'cloud queue destinations create my-queue --url https://example.com/webhook'
+			),
+			description: 'Create a webhook destination',
+		},
+	],
+	schema: {
+		args: z.object({
+			queue_name: z.string().min(1).describe('Queue name'),
+		}),
+		options: z.object({
+			url: z.string().url().describe('Webhook URL'),
+			method: z.string().default('POST').optional().describe('HTTP method (default: POST)'),
+			timeout: z.coerce.number().optional().describe('Request timeout in milliseconds'),
+		}),
+		response: DestinationSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const client = await createQueueAPIClient(ctx);
+
+		try {
+			const destination = await createDestination(
+				client,
+				args.queue_name,
+				{
+					destination_type: 'http',
+					config: {
+						url: opts.url,
+						method: opts.method || 'POST',
+						timeout_ms: opts.timeout ?? 30000,
+					},
+					enabled: true,
+				},
+				getQueueApiOptions(ctx)
+			);
+
+			if (!options.json) {
+				tui.success(`Created destination: ${destination.id}`);
+				console.log(`  URL:    ${destination.config.url}`);
+				console.log(`  Method: ${destination.config.method}`);
+			}
+
+			return destination;
+		} catch (error) {
+			if (error instanceof DestinationAlreadyExistsError) {
+				tui.fatal(
+					`A destination with URL "${opts.url}" already exists for queue "${args.queue_name}". Use a different URL or delete the existing destination first.`,
+					ErrorCode.RESOURCE_ALREADY_EXISTS
+				);
+			}
+			throw error;
+		}
+	},
+});
+
+const updateDestinationSubcommand = createSubcommand({
+	name: 'update',
+	description: 'Update a destination',
+	tags: ['mutating', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud queue destinations update my-queue dest_abc123 --disabled'),
+			description: 'Disable a destination',
+		},
+	],
+	schema: {
+		args: z.object({
+			queue_name: z.string().min(1).describe('Queue name'),
+			destination_id: z.string().min(1).describe('Destination ID'),
+		}),
+		options: z.object({
+			url: z.string().url().optional().describe('Webhook URL'),
+			method: z.string().optional().describe('HTTP method'),
+			timeout: z.coerce.number().optional().describe('Request timeout in milliseconds'),
+			enabled: z.boolean().optional().describe('Enable the destination'),
+			disabled: z.boolean().optional().describe('Disable the destination'),
+		}),
+		response: DestinationSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const client = await createQueueAPIClient(ctx);
+
+		const updateParams: {
+			config?: { url?: string; method?: string; timeout_ms?: number };
+			enabled?: boolean;
+		} = {};
+
+		if (opts.url || opts.method || opts.timeout !== undefined) {
+			updateParams.config = {};
+			if (opts.url) updateParams.config.url = opts.url;
+			if (opts.method) updateParams.config.method = opts.method;
+			if (opts.timeout !== undefined) updateParams.config.timeout_ms = opts.timeout;
+		}
+		if (opts.enabled && opts.disabled) {
+			tui.fatal(
+				'Cannot specify both --enabled and --disabled flags',
+				ErrorCode.INVALID_ARGUMENT
+			);
+		}
+		if (opts.enabled) updateParams.enabled = true;
+		if (opts.disabled) updateParams.enabled = false;
+
+		const destination = await updateDestination(
+			client,
+			args.queue_name,
+			args.destination_id,
+			updateParams,
+			getQueueApiOptions(ctx)
+		);
+
+		if (!options.json) {
+			tui.success(`Updated destination: ${destination.id}`);
+			console.log(`  URL:     ${destination.config.url}`);
+			console.log(`  Enabled: ${destination.enabled ? 'Yes' : 'No'}`);
+		}
+
+		return destination;
+	},
+});
+
+const DeleteDestinationResponseSchema = z.object({
+	success: z.boolean(),
+	queue_name: z.string(),
+	destination_id: z.string(),
+});
+
+const deleteDestinationSubcommand = createSubcommand({
+	name: 'delete',
+	aliases: ['rm'],
+	description: 'Delete a destination from a queue',
+	tags: ['mutating', 'deletes-resource', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud queue destinations delete my-queue dest-123'),
+			description: 'Delete a destination',
+		},
+	],
+	schema: {
+		args: z.object({
+			queue_name: z.string().min(1).describe('Queue name'),
+			destination_id: z.string().min(1).describe('Destination ID'),
+		}),
+		response: DeleteDestinationResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const client = await createQueueAPIClient(ctx);
+		await deleteDestination(
+			client,
+			args.queue_name,
+			args.destination_id,
+			getQueueApiOptions(ctx)
+		);
+
+		if (!options.json) {
+			tui.success(`Deleted destination: ${args.destination_id}`);
+		}
+
+		return {
+			success: true,
+			queue_name: args.queue_name,
+			destination_id: args.destination_id,
+		};
+	},
+});
+
+export const destinationsSubcommand = createCommand({
+	name: 'destinations',
+	aliases: ['dest'],
+	description: 'Manage queue destinations (webhooks)',
+	tags: ['requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud queue destinations list my-queue'),
+			description: 'List destinations',
+		},
+		{
+			command: getCommand(
+				'cloud queue destinations create my-queue --url https://example.com/webhook'
+			),
+			description: 'Create a webhook destination',
+		},
+	],
+	subcommands: [
+		listDestinationsSubcommand,
+		createDestinationSubcommand,
+		updateDestinationSubcommand,
+		deleteDestinationSubcommand,
+	],
+});
+
+export default destinationsSubcommand;

package/src/cmd/cloud/queue/dlq.ts

@@ -0,0 +1,203 @@
+import { z } from 'zod';
+import { createCommand, createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createQueueAPIClient, getQueueApiOptions } from './util';
+import { getCommand } from '../../../command-prefix';
+import {
+	listDeadLetterMessages,
+	replayDeadLetterMessage,
+	purgeDeadLetter,
+	type DeadLetterMessage,
+	MessageSchema,
+} from '@agentuity/server';
+import { ErrorCode } from '../../../errors';
+
+const DlqListResponseSchema = z.object({
+	messages: z.array(
+		z.object({
+			id: z.string(),
+			offset: z.number(),
+			failure_reason: z.string().nullable(),
+			delivery_attempts: z.number(),
+			moved_at: z.string(),
+		})
+	),
+	total: z.number().optional(),
+});
+
+const listDlqSubcommand = createSubcommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List messages in the dead letter queue',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud queue dlq list my-queue'),
+			description: 'List DLQ messages',
+		},
+	],
+	schema: {
+		args: z.object({
+			queue_name: z.string().min(1).describe('Queue name'),
+		}),
+		options: z.object({
+			limit: z.coerce.number().optional().describe('Maximum number of messages to return'),
+			offset: z.coerce.number().optional().describe('Offset for pagination'),
+		}),
+		response: DlqListResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const client = await createQueueAPIClient(ctx);
+		const result = await listDeadLetterMessages(
+			client,
+			args.queue_name,
+			{
+				limit: opts.limit,
+				offset: opts.offset,
+			},
+			getQueueApiOptions(ctx)
+		);
+
+		if (!options.json) {
+			if (result.messages.length === 0) {
+				tui.info('No messages in dead letter queue');
+			} else {
+				const tableData = result.messages.map((m: DeadLetterMessage) => ({
+					ID: m.id.substring(0, 8) + '...',
+					Offset: m.offset,
+					Reason: m.failure_reason?.substring(0, 30) || 'Unknown',
+					Attempts: m.delivery_attempts,
+					'Moved At': new Date(m.moved_at).toLocaleString(),
+				}));
+				tui.table(tableData, ['ID', 'Offset', 'Reason', 'Attempts', 'Moved At']);
+			}
+		}
+
+		return {
+			messages: result.messages.map((m: DeadLetterMessage) => ({
+				id: m.id,
+				offset: m.offset,
+				failure_reason: m.failure_reason ?? null,
+				delivery_attempts: m.delivery_attempts,
+				moved_at: m.moved_at,
+			})),
+			total: result.total,
+		};
+	},
+});
+
+const ReplayResponseSchema = z.object({
+	success: z.boolean(),
+	message: MessageSchema,
+});
+
+const replayDlqSubcommand = createSubcommand({
+	name: 'replay',
+	description: 'Replay a message from the dead letter queue',
+	tags: ['mutating', 'updates-resource', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud queue dlq replay my-queue msg-123'),
+			description: 'Replay a DLQ message',
+		},
+	],
+	schema: {
+		args: z.object({
+			queue_name: z.string().min(1).describe('Queue name'),
+			message_id: z.string().min(1).describe('Message ID'),
+		}),
+		response: ReplayResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const client = await createQueueAPIClient(ctx);
+		const message = await replayDeadLetterMessage(
+			client,
+			args.queue_name,
+			args.message_id,
+			getQueueApiOptions(ctx)
+		);
+
+		if (!options.json) {
+			tui.success(`Replayed message: ${message.id}`);
+			tui.info(`  New offset: ${message.offset}`);
+		}
+
+		return {
+			success: true,
+			message,
+		};
+	},
+});
+
+const PurgeResponseSchema = z.object({
+	success: z.boolean(),
+	queue_name: z.string(),
+});
+
+const purgeDlqSubcommand = createSubcommand({
+	name: 'purge',
+	description: 'Purge all messages from the dead letter queue',
+	tags: ['mutating', 'deletes-resource', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud queue dlq purge my-queue --confirm'),
+			description: 'Purge all DLQ messages',
+		},
+	],
+	schema: {
+		args: z.object({
+			queue_name: z.string().min(1).describe('Queue name'),
+		}),
+		options: z.object({
+			confirm: z.boolean().default(false).describe('Skip confirmation prompt'),
+		}),
+		response: PurgeResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+
+		if (!opts.confirm) {
+			tui.fatal('Use --confirm to confirm DLQ purge', ErrorCode.INVALID_ARGUMENT);
+		}
+
+		const client = await createQueueAPIClient(ctx);
+		await purgeDeadLetter(client, args.queue_name, getQueueApiOptions(ctx));
+
+		if (!options.json) {
+			tui.success(`Purged dead letter queue for: ${args.queue_name}`);
+		}
+
+		return {
+			success: true,
+			queue_name: args.queue_name,
+		};
+	},
+});
+
+export const dlqSubcommand = createCommand({
+	name: 'dlq',
+	description: 'Dead letter queue operations',
+	tags: ['requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud queue dlq list my-queue'),
+			description: 'List DLQ messages',
+		},
+		{
+			command: getCommand('cloud queue dlq replay my-queue msg-123'),
+			description: 'Replay a message',
+		},
+	],
+	subcommands: [listDlqSubcommand, replayDlqSubcommand, purgeDlqSubcommand],
+});
+
+export default dlqSubcommand;