@agentuity/cli 0.1.15 → 0.1.17

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

@@ -1,34 +1,25 @@
-import { KeyValueStorageService, Logger } from '@agentuity/core';
+import { KeyValueStorageService, type Logger } from '@agentuity/core';
 import { createServerFetchAdapter, getServiceUrls } from '@agentuity/server';
-import { loadProjectSDKKey } from '../../../config';
-import { ErrorCode } from '../../../errors';
-import type { Config } from '../../../types';
-import * as tui from '../../../tui';
+import { getDefaultRegion } from '../../../config';
+import type { AuthData, Config } from '../../../types';
 
 export async function createStorageAdapter(ctx: {
 	logger: Logger;
-	projectDir: string;
 	config: Config | null;
-	project: { region: string };
+	auth: AuthData;
+	project?: { region: string };
 }) {
-	const sdkKey = await loadProjectSDKKey(ctx.logger, ctx.projectDir);
-	if (!sdkKey) {
-		tui.fatal(
-			`Couldn't find the AGENTUITY_SDK_KEY in ${ctx.projectDir} .env file`,
-			ErrorCode.CONFIG_NOT_FOUND
-		);
-	}
-
 	const adapter = createServerFetchAdapter(
 		{
 			headers: {
-				Authorization: `Bearer ${sdkKey}`,
+				Authorization: `Bearer ${ctx.auth.apiKey}`,
 			},
 		},
 		ctx.logger
 	);
 
-	const urls = getServiceUrls(ctx.project.region);
+	const region = ctx.project?.region || (await getDefaultRegion(ctx.config?.name, ctx.config));
+	const urls = getServiceUrls(region);
 	const baseUrl = urls.catalyst;
 	return new KeyValueStorageService(baseUrl, adapter);
 }

package/src/cmd/cloud/queue/ack.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 { ackMessage } from '@agentuity/server';
+
+const AckResponseSchema = z.object({
+	success: z.boolean(),
+	queue_name: z.string(),
+	message_id: z.string(),
+});
+
+export const ackSubcommand = createCommand({
+	name: 'ack',
+	description: 'Acknowledge a message (mark as processed)',
+	tags: ['mutating', 'updates-resource', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud queue ack my-queue msg-123'),
+			description: 'Acknowledge a message',
+		},
+	],
+	schema: {
+		args: z.object({
+			queue_name: z.string().min(1).describe('Queue name'),
+			message_id: z.string().min(1).describe('Message ID'),
+		}),
+		response: AckResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const client = await createQueueAPIClient(ctx);
+		await ackMessage(client, args.queue_name, args.message_id, getQueueApiOptions(ctx));
+
+		if (!options.json) {
+			tui.success(`Acknowledged message: ${args.message_id}`);
+		}
+
+		return {
+			success: true,
+			queue_name: args.queue_name,
+			message_id: args.message_id,
+		};
+	},
+});
+
+export default ackSubcommand;

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;