@agentuity/cli 0.1.15 → 0.1.17

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

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createQueueAPIClient, getQueueApiOptions } from './util';
+import { getCommand } from '../../../command-prefix';
+import { nackMessage } from '@agentuity/server';
+
+const NackResponseSchema = z.object({
+	success: z.boolean(),
+	queue_name: z.string(),
+	message_id: z.string(),
+});
+
+export const nackSubcommand = createCommand({
+	name: 'nack',
+	description: 'Negative acknowledge a message (return to queue for retry)',
+	tags: ['mutating', 'updates-resource', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud queue nack my-queue msg-123'),
+			description: 'Return message to queue for retry',
+		},
+	],
+	schema: {
+		args: z.object({
+			queue_name: z.string().min(1).describe('Queue name'),
+			message_id: z.string().min(1).describe('Message ID'),
+		}),
+		response: NackResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const client = await createQueueAPIClient(ctx);
+		await nackMessage(client, args.queue_name, args.message_id, getQueueApiOptions(ctx));
+
+		if (!options.json) {
+			tui.success(`Returned message to queue: ${args.message_id}`);
+		}
+
+		return {
+			success: true,
+			queue_name: args.queue_name,
+			message_id: args.message_id,
+		};
+	},
+});
+
+export default nackSubcommand;

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

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createQueueAPIClient, getQueueApiOptions } from './util';
+import { getCommand } from '../../../command-prefix';
+import { pauseQueue, QueueSchema } from '@agentuity/server';
+
+export const pauseSubcommand = createCommand({
+	name: 'pause',
+	description: 'Pause message delivery for a queue',
+	tags: ['mutating', 'updates-resource', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud queue pause my-queue'),
+			description: 'Pause a queue',
+		},
+	],
+	schema: {
+		args: z.object({
+			name: z.string().min(1).describe('Queue name'),
+		}),
+		response: QueueSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const client = await createQueueAPIClient(ctx);
+
+		const queue = await pauseQueue(client, args.name, getQueueApiOptions(ctx));
+
+		if (!options.json) {
+			tui.success(`Paused queue: ${queue.name}`);
+			tui.info(`  Paused at: ${queue.paused_at}`);
+		}
+
+		return queue;
+	},
+});
+
+export default pauseSubcommand;

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

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createQueueAPIClient, getQueueApiOptions } from './util';
+import { getCommand } from '../../../command-prefix';
+import { publishMessage, MessageSchema } from '@agentuity/server';
+import { ErrorCode } from '../../../errors';
+
+export const publishSubcommand = createCommand({
+	name: 'publish',
+	aliases: ['pub', 'send'],
+	description: 'Publish a message to a queue',
+	tags: ['mutating', 'creates-resource', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud queue publish my-queue \'{"task":"process"}\''),
+			description: 'Publish a JSON message',
+		},
+		{
+			command: getCommand(
+				'cloud queue publish my-queue \'{"task":"process"}\' --metadata \'{"priority":"high"}\''
+			),
+			description: 'Publish with metadata',
+		},
+		{
+			command: getCommand('cloud queue publish my-queue "hello" --ttl 3600'),
+			description: 'Publish with 1h TTL',
+		},
+	],
+	schema: {
+		args: z.object({
+			queue_name: z.string().min(1).describe('Queue name'),
+			payload: z.string().min(1).describe('Message payload (JSON)'),
+		}),
+		options: z.object({
+			metadata: z.string().optional().describe('Message metadata as JSON'),
+			partitionKey: z.string().optional().describe('Partition key for ordering'),
+			idempotencyKey: z.string().optional().describe('Idempotency key to prevent duplicates'),
+			ttl: z.coerce.number().optional().describe('Message TTL in seconds'),
+		}),
+		response: MessageSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const client = await createQueueAPIClient(ctx);
+
+		let payload: unknown;
+		try {
+			payload = JSON.parse(args.payload);
+		} catch {
+			tui.fatal('Invalid payload JSON', ErrorCode.INVALID_ARGUMENT);
+		}
+
+		let metadata: Record<string, unknown> | undefined;
+		if (opts.metadata) {
+			try {
+				metadata = JSON.parse(opts.metadata);
+			} catch {
+				tui.fatal('Invalid metadata JSON', ErrorCode.INVALID_ARGUMENT);
+			}
+		}
+
+		const message = await publishMessage(
+			client,
+			args.queue_name,
+			{
+				payload,
+				metadata,
+				partition_key: opts.partitionKey,
+				idempotency_key: opts.idempotencyKey,
+				ttl_seconds: opts.ttl,
+			},
+			getQueueApiOptions(ctx)
+		);
+
+		if (!options.json) {
+			tui.success(`Published message: ${message.id}`);
+			console.log(`  Offset: ${message.offset}`);
+			console.log(`  State:  ${message.state}`);
+		}
+
+		return message;
+	},
+});
+
+export default publishSubcommand;

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

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createQueueAPIClient, getQueueApiOptions } from './util';
+import { getCommand } from '../../../command-prefix';
+import { receiveMessage, MessageSchema } from '@agentuity/server';
+
+const ReceiveResponseSchema = z.object({
+	message: MessageSchema.nullable(),
+});
+
+export const receiveSubcommand = createCommand({
+	name: 'receive',
+	aliases: ['recv', 'claim'],
+	description: 'Receive (claim) a message from a worker queue',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud queue receive my-queue'),
+			description: 'Receive next message',
+		},
+		{
+			command: getCommand('cloud queue receive my-queue --timeout 60'),
+			description: 'Receive with 60s visibility timeout',
+		},
+	],
+	schema: {
+		args: z.object({
+			queue_name: z.string().min(1).describe('Queue name'),
+		}),
+		options: z.object({
+			timeout: z.coerce
+				.number()
+				.default(30)
+				.optional()
+				.describe('Visibility timeout in seconds (default: 30)'),
+		}),
+		response: ReceiveResponseSchema,
+	},
+	idempotent: true,
+
+	async handler(ctx) {
+		const { args, options, opts } = ctx;
+		const client = await createQueueAPIClient(ctx);
+		const message = await receiveMessage(
+			client,
+			args.queue_name,
+			opts.timeout,
+			getQueueApiOptions(ctx)
+		);
+
+		if (!options.json) {
+			if (!message) {
+				tui.info('No messages available');
+			} else {
+				tui.success(`Received message: ${message.id}`);
+				tui.info(`  Offset: ${message.offset}`);
+				tui.info(`  State: ${message.state}`);
+				tui.info(`  Delivery Attempts: ${message.delivery_attempts}`);
+				tui.info('');
+				tui.info('Payload:');
+				tui.json(message.payload);
+				if (message.metadata) {
+					tui.info('');
+					tui.info('Metadata:');
+					tui.json(message.metadata);
+				}
+			}
+		}
+
+		return { message };
+	},
+});
+
+export default receiveSubcommand;

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

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createQueueAPIClient, getQueueApiOptions } from './util';
+import { getCommand } from '../../../command-prefix';
+import { resumeQueue, QueueSchema } from '@agentuity/server';
+
+export const resumeSubcommand = createCommand({
+	name: 'resume',
+	description: 'Resume message delivery for a paused queue',
+	tags: ['mutating', 'updates-resource', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud queue resume my-queue'),
+			description: 'Resume a paused queue',
+		},
+	],
+	schema: {
+		args: z.object({
+			name: z.string().min(1).describe('Queue name'),
+		}),
+		response: QueueSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const client = await createQueueAPIClient(ctx);
+
+		const queue = await resumeQueue(client, args.name, getQueueApiOptions(ctx));
+
+		if (!options.json) {
+			tui.success(`Resumed queue: ${queue.name}`);
+		}
+
+		return queue;
+	},
+});
+
+export default resumeSubcommand;

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

@@ -0,0 +1,352 @@
+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 {
+	createSource,
+	listSources,
+	getSource,
+	updateSource,
+	deleteSource,
+	SourceSchema,
+	SourceAlreadyExistsError,
+	type Source,
+} from '@agentuity/server';
+import { ErrorCode } from '../../../errors';
+
+const SourcesListResponseSchema = z.object({
+	sources: z.array(
+		z.object({
+			id: z.string(),
+			name: z.string(),
+			auth_type: z.string(),
+			enabled: z.boolean(),
+			url: z.string(),
+			created_at: z.string(),
+		})
+	),
+});
+
+const listSourcesSubcommand = createSubcommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List sources for a queue',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud queue sources list my-queue'),
+			description: 'List queue sources',
+		},
+	],
+	schema: {
+		args: z.object({
+			queue_name: z.string().min(1).describe('Queue name'),
+		}),
+		response: SourcesListResponseSchema,
+	},
+	idempotent: true,
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const client = await createQueueAPIClient(ctx);
+		const sources = await listSources(client, args.queue_name, getQueueApiOptions(ctx));
+
+		if (!options.json) {
+			if (sources.length === 0) {
+				tui.info('No sources configured');
+			} else {
+				const tableData = sources.map((s: Source) => ({
+					ID: s.id,
+					Name: s.name,
+					'Auth Type': s.auth_type,
+					Enabled: s.enabled ? 'Yes' : 'No',
+					URL: s.url,
+					Created: new Date(s.created_at).toLocaleString(),
+				}));
+				tui.table(tableData, ['ID', 'Name', 'Auth Type', 'Enabled', 'URL', 'Created']);
+			}
+		}
+
+		return {
+			sources: sources.map((s: Source) => ({
+				id: s.id,
+				name: s.name,
+				auth_type: s.auth_type,
+				enabled: s.enabled,
+				url: s.url,
+				created_at: s.created_at,
+			})),
+		};
+	},
+});
+
+const createSourceSubcommand = createSubcommand({
+	name: 'create',
+	description: 'Create a source for a queue',
+	tags: ['mutating', 'creates-resource', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand(
+				'cloud queue sources create my-queue --name webhook-1 --auth-type header --auth-value "X-API-Key:secret123"'
+			),
+			description: 'Create a source with header authentication',
+		},
+	],
+	schema: {
+		args: z.object({
+			queue_name: z.string().min(1).describe('Queue name'),
+		}),
+		options: z.object({
+			name: z.string().min(1).describe('Source name'),
+			description: z.string().optional().describe('Source description'),
+			'auth-type': z
+				.enum(['none', 'basic', 'header'])
+				.default('none')
+				.optional()
+				.describe('Authentication type'),
+			'auth-value': z.string().optional().describe('Authentication value'),
+		}),
+		response: SourceSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const client = await createQueueAPIClient(ctx);
+
+		try {
+			const source = await createSource(
+				client,
+				args.queue_name,
+				{
+					name: opts.name,
+					description: opts.description,
+					auth_type: opts['auth-type'] || 'none',
+					auth_value: opts['auth-value'],
+				},
+				getQueueApiOptions(ctx)
+			);
+
+			if (!options.json) {
+				tui.success(`Created source: ${source.id}`);
+				console.log(`  Name: ${source.name}`);
+				console.log(`  URL:  ${source.url}`);
+			}
+
+			return source;
+		} catch (error) {
+			if (error instanceof SourceAlreadyExistsError) {
+				tui.fatal(
+					`A source with name "${opts.name}" already exists for queue "${args.queue_name}". Use a different name or delete the existing source first.`,
+					ErrorCode.RESOURCE_ALREADY_EXISTS
+				);
+			}
+			throw error;
+		}
+	},
+});
+
+const getSourceSubcommand = createSubcommand({
+	name: 'get',
+	description: 'Get a source by ID',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud queue sources get my-queue qsrc_abc123'),
+			description: 'Get source details',
+		},
+	],
+	schema: {
+		args: z.object({
+			queue_name: z.string().min(1).describe('Queue name'),
+			source_id: z.string().min(1).describe('Source ID'),
+		}),
+		response: SourceSchema,
+	},
+	idempotent: true,
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const client = await createQueueAPIClient(ctx);
+		const source = await getSource(
+			client,
+			args.queue_name,
+			args.source_id,
+			getQueueApiOptions(ctx)
+		);
+
+		if (!options.json) {
+			console.log(`ID:          ${source.id}`);
+			console.log(`Name:        ${source.name}`);
+			console.log(`Description: ${source.description || '-'}`);
+			console.log(`Auth Type:   ${source.auth_type}`);
+			console.log(`Enabled:     ${source.enabled ? 'Yes' : 'No'}`);
+			console.log(`URL:         ${source.url}`);
+			console.log('');
+			console.log('Stats:');
+			console.log(`  Requests:  ${source.request_count}`);
+			console.log(`  Successes: ${source.success_count}`);
+			console.log(`  Failures:  ${source.failure_count}`);
+			if (source.last_request_at) {
+				console.log(`  Last Request: ${new Date(source.last_request_at).toLocaleString()}`);
+			}
+			if (source.last_failure_error) {
+				console.log(`  Last Error: ${source.last_failure_error}`);
+			}
+			console.log('');
+			console.log(`Created: ${new Date(source.created_at).toLocaleString()}`);
+			console.log(`Updated: ${new Date(source.updated_at).toLocaleString()}`);
+		}
+
+		return source;
+	},
+});
+
+const updateSourceSubcommand = createSubcommand({
+	name: 'update',
+	description: 'Update a source',
+	tags: ['mutating', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud queue sources update my-queue qsrc_abc123 --disabled'),
+			description: 'Disable a source',
+		},
+	],
+	schema: {
+		args: z.object({
+			queue_name: z.string().min(1).describe('Queue name'),
+			source_id: z.string().min(1).describe('Source ID'),
+		}),
+		options: z.object({
+			name: z.string().optional().describe('New source name'),
+			description: z.string().optional().describe('New description'),
+			'auth-type': z
+				.enum(['none', 'basic', 'header'])
+				.optional()
+				.describe('Authentication type'),
+			'auth-value': z.string().optional().describe('Authentication value'),
+			enabled: z.boolean().optional().describe('Enable the source'),
+			disabled: z.boolean().optional().describe('Disable the source'),
+		}),
+		response: SourceSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const client = await createQueueAPIClient(ctx);
+
+		const updateParams: {
+			name?: string;
+			description?: string;
+			auth_type?: 'none' | 'basic' | 'header';
+			auth_value?: string;
+			enabled?: boolean;
+		} = {};
+
+		if (opts.name) updateParams.name = opts.name;
+		if (opts.description) updateParams.description = opts.description;
+		if (opts['auth-type']) updateParams.auth_type = opts['auth-type'];
+		if (opts['auth-value']) updateParams.auth_value = opts['auth-value'];
+		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 source = await updateSource(
+			client,
+			args.queue_name,
+			args.source_id,
+			updateParams,
+			getQueueApiOptions(ctx)
+		);
+
+		if (!options.json) {
+			tui.success(`Updated source: ${source.id}`);
+			console.log(`  Name:    ${source.name}`);
+			console.log(`  Enabled: ${source.enabled ? 'Yes' : 'No'}`);
+			console.log(`  URL:     ${source.url}`);
+		}
+
+		return source;
+	},
+});
+
+const DeleteSourceResponseSchema = z.object({
+	success: z.boolean(),
+	queue_name: z.string(),
+	source_id: z.string(),
+});
+
+const deleteSourceSubcommand = createSubcommand({
+	name: 'delete',
+	aliases: ['rm'],
+	description: 'Delete a source from a queue',
+	tags: ['mutating', 'deletes-resource', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud queue sources delete my-queue qsrc_abc123'),
+			description: 'Delete a source',
+		},
+	],
+	schema: {
+		args: z.object({
+			queue_name: z.string().min(1).describe('Queue name'),
+			source_id: z.string().min(1).describe('Source ID'),
+		}),
+		response: DeleteSourceResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const client = await createQueueAPIClient(ctx);
+		await deleteSource(client, args.queue_name, args.source_id, getQueueApiOptions(ctx));
+
+		if (!options.json) {
+			tui.success(`Deleted source: ${args.source_id}`);
+		}
+
+		return {
+			success: true,
+			queue_name: args.queue_name,
+			source_id: args.source_id,
+		};
+	},
+});
+
+export const sourcesSubcommand = createCommand({
+	name: 'sources',
+	aliases: ['source'],
+	description: 'Manage queue sources (HTTP ingestion endpoints)',
+	tags: ['requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud queue sources list my-queue'),
+			description: 'List sources',
+		},
+		{
+			command: getCommand(
+				'cloud queue sources create my-queue --name webhook-1 --auth-type header --auth-value "X-API-Key:secret"'
+			),
+			description: 'Create a source with header authentication',
+		},
+	],
+	subcommands: [
+		listSourcesSubcommand,
+		createSourceSubcommand,
+		getSourceSubcommand,
+		updateSourceSubcommand,
+		deleteSourceSubcommand,
+	],
+});
+
+export default sourcesSubcommand;