@agentuity/cli 0.0.59 → 0.0.61

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

@@ -0,0 +1,198 @@
+import { z } from 'zod';
+import { listResources, deleteResources } from '@agentuity/server';
+import enquirer from 'enquirer';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCatalystAPIClient } from '../../../config';
+import { getCommand } from '../../../command-prefix';
+import { isDryRunMode, outputDryRun } from '../../../explain';
+import { ErrorCode } from '../../../errors';
+import { createS3Client } from './utils';
+
+export const deleteSubcommand = createSubcommand({
+	name: 'delete',
+	aliases: ['rm', 'del', 'remove'],
+	description: 'Delete a storage resource or file',
+	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth', 'requires-deployment'],
+	idempotent: false,
+	requires: { auth: true, org: true, region: true },
+	examples: [
+		{ command: getCommand('cloud storage delete my-bucket'), description: 'Delete item' },
+		{ command: getCommand('cloud storage rm my-bucket file.txt'), description: 'Delete item' },
+		{ command: getCommand('cloud storage delete'), description: 'Delete item' },
+		{
+			command: getCommand('--dry-run cloud storage delete my-bucket'),
+			description: 'Delete item',
+		},
+	],
+	schema: {
+		args: z.object({
+			name: z.string().optional().describe('Bucket name'),
+			filename: z.string().optional().describe('File path to delete from bucket'),
+		}),
+		options: z.object({
+			confirm: z.boolean().optional().describe('Skip confirmation prompts'),
+		}),
+		response: z.object({
+			success: z.boolean().describe('Whether deletion succeeded'),
+			name: z.string().describe('Deleted bucket or file name'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { logger, args, opts, config, orgId, region, auth, options } = ctx;
+
+		const catalystClient = getCatalystAPIClient(config, logger, auth);
+
+		const resources = await tui.spinner({
+			message: `Fetching storage for ${orgId} in ${region}`,
+			clearOnSuccess: true,
+			callback: async () => {
+				return listResources(catalystClient, orgId, region!);
+			},
+		});
+
+		let bucketName = args.name;
+
+		if (!bucketName) {
+			if (resources.s3.length === 0) {
+				tui.info('No storage buckets found to delete');
+				return { success: false, name: '' };
+			}
+
+			const response = await enquirer.prompt<{ bucket: string }>({
+				type: 'select',
+				name: 'bucket',
+				message: 'Select storage bucket to delete:',
+				choices: resources.s3.map((s3) => ({
+					name: s3.bucket_name,
+					message: s3.bucket_name,
+				})),
+			});
+
+			bucketName = response.bucket;
+		}
+
+		// If filename is provided, delete the file from the bucket
+		if (args.filename) {
+			const bucket = resources.s3.find((s3) => s3.bucket_name === bucketName);
+
+			if (!bucket) {
+				tui.fatal(`Storage bucket '${bucketName}' not found`, ErrorCode.RESOURCE_NOT_FOUND);
+			}
+
+			if (!bucket.access_key || !bucket.secret_key || !bucket.endpoint) {
+				tui.fatal(
+					`Storage bucket '${bucketName}' is missing credentials`,
+					ErrorCode.CONFIG_INVALID
+				);
+			}
+
+			// Handle dry-run mode
+			if (isDryRunMode(options)) {
+				outputDryRun(`Would delete file ${args.filename} from bucket ${bucketName}`, options);
+				if (!options.json) {
+					tui.newline();
+					tui.info('[DRY RUN] File deletion skipped');
+				}
+				return {
+					success: false,
+					name: args.filename,
+				};
+			}
+
+			if (!opts.confirm) {
+				tui.warning(
+					`You are about to delete file: ${tui.bold(args.filename)} from bucket: ${tui.bold(bucketName)}`
+				);
+
+				const confirm = await enquirer.prompt<{ confirm: boolean }>({
+					type: 'confirm',
+					name: 'confirm',
+					message: 'Are you sure you want to delete this file?',
+					initial: false,
+				});
+
+				if (!confirm.confirm) {
+					tui.info('Deletion cancelled');
+					return { success: false, name: args.filename };
+				}
+			}
+
+			const s3Client = createS3Client({
+				endpoint: bucket.endpoint,
+				access_key: bucket.access_key,
+				secret_key: bucket.secret_key,
+				region: bucket.region,
+			});
+
+			await tui.spinner({
+				message: `Deleting ${args.filename} from ${bucketName}`,
+				clearOnSuccess: true,
+				callback: async () => {
+					await s3Client.delete(args.filename!);
+				},
+			});
+
+			if (!options.json) {
+				tui.success(`Deleted file: ${tui.bold(args.filename)} from ${tui.bold(bucketName)}`);
+			}
+
+			return {
+				success: true,
+				name: args.filename,
+			};
+		}
+
+		// Otherwise, delete the bucket
+		// Handle dry-run mode
+		if (isDryRunMode(options)) {
+			outputDryRun(`Would delete storage bucket: ${bucketName}`, options);
+			if (!options.json) {
+				tui.newline();
+				tui.info('[DRY RUN] Storage bucket deletion skipped');
+			}
+			return {
+				success: false,
+				name: bucketName,
+			};
+		}
+
+		if (!opts.confirm) {
+			tui.warning(`You are about to delete storage bucket: ${tui.bold(bucketName)}`);
+
+			const confirm = await enquirer.prompt<{ confirm: boolean }>({
+				type: 'confirm',
+				name: 'confirm',
+				message: 'Are you sure you want to delete this storage bucket?',
+				initial: false,
+			});
+
+			if (!confirm.confirm) {
+				tui.info('Deletion cancelled');
+				return { success: false, name: bucketName };
+			}
+		}
+
+		const deleted = await tui.spinner({
+			message: `Deleting storage bucket ${bucketName}`,
+			clearOnSuccess: true,
+			callback: async () => {
+				return deleteResources(catalystClient, orgId, region!, [
+					{ type: 's3', name: bucketName },
+				]);
+			},
+		});
+
+		if (deleted.length > 0) {
+			tui.success(`Deleted storage bucket: ${tui.bold(deleted[0])}`);
+			return {
+				success: true,
+				name: deleted[0],
+			};
+		} else {
+			tui.error('Failed to delete storage bucket');
+			return { success: false, name: bucketName };
+		}
+	},
+});

package/src/cmd/cloud/storage/download.ts

@@ -0,0 +1,166 @@
+import { z } from 'zod';
+import { listResources } from '@agentuity/server';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCatalystAPIClient } from '../../../config';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+import { createS3Client } from './utils';
+
+export const downloadSubcommand = createSubcommand({
+	name: 'download',
+	description: 'Download a file from storage bucket',
+	tags: ['read-only', 'requires-auth'],
+	requires: { auth: true, org: true, region: true },
+	idempotent: true,
+	examples: [
+		{
+			command: `${getCommand('cloud storage download')} my-bucket file.txt`,
+			description: 'Download file from bucket',
+		},
+		{
+			command: `${getCommand('cloud storage download')} my-bucket file.txt output.txt`,
+			description: 'Download file to specific path',
+		},
+		{
+			command: `${getCommand('cloud storage download')} my-bucket file.txt - > output.txt`,
+			description: 'Download file to stdout',
+		},
+		{
+			command: `${getCommand('cloud storage download')} my-bucket file.txt --metadata`,
+			description: 'Download metadata only',
+		},
+	],
+	schema: {
+		args: z.object({
+			name: z.string().describe('Bucket name'),
+			filename: z.string().describe('File path to download'),
+			output: z.string().optional().describe('Output file path or "-" for STDOUT'),
+		}),
+		options: z.object({
+			metadata: z.boolean().optional().describe('Download metadata only (not file contents)'),
+		}),
+		response: z.object({
+			success: z.boolean().describe('Whether download succeeded'),
+			bucket: z.string().describe('Bucket name'),
+			filename: z.string().describe('Downloaded filename'),
+			size: z.number().optional().describe('File size in bytes'),
+			contentType: z.string().optional().describe('Content type'),
+			lastModified: z.string().optional().describe('Last modified timestamp'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { logger, args, opts, options, orgId, region, config, auth } = ctx;
+
+		const catalystClient = getCatalystAPIClient(config, logger, auth);
+
+		// Fetch bucket credentials
+		const resources = await tui.spinner({
+			message: `Fetching credentials for ${args.name}`,
+			clearOnSuccess: true,
+			callback: async () => {
+				return listResources(catalystClient, orgId, region);
+			},
+		});
+
+		const bucket = resources.s3.find((s3) => s3.bucket_name === args.name);
+
+		if (!bucket) {
+			tui.fatal(`Storage bucket '${args.name}' not found`, ErrorCode.RESOURCE_NOT_FOUND);
+		}
+
+		if (!bucket.access_key || !bucket.secret_key || !bucket.endpoint) {
+			tui.fatal(
+				`Storage bucket '${args.name}' is missing credentials`,
+				ErrorCode.CONFIG_INVALID
+			);
+		}
+
+		// Initialize S3 client
+		const s3Client = createS3Client({
+			endpoint: bucket.endpoint,
+			access_key: bucket.access_key,
+			secret_key: bucket.secret_key,
+			region: bucket.region,
+		});
+
+		if (opts.metadata) {
+			// Download metadata only
+			const metadata = await tui.spinner({
+				message: `Fetching metadata for ${args.filename}`,
+				clearOnSuccess: true,
+				callback: async () => {
+					return s3Client.stat(args.filename);
+				},
+			});
+
+			if (!options.json) {
+				console.log(tui.bold('File:          ') + args.filename);
+				console.log(tui.bold('Bucket:        ') + args.name);
+				if (metadata.size) {
+					console.log(tui.bold('Size:          ') + metadata.size + ' bytes');
+				}
+				if (metadata.type) {
+					console.log(tui.bold('Content Type:  ') + metadata.type);
+				}
+				if (metadata.lastModified) {
+					console.log(tui.bold('Last Modified: ') + metadata.lastModified);
+				}
+			}
+
+			return {
+				success: true,
+				bucket: args.name,
+				filename: args.filename,
+				size: metadata.size,
+				contentType: metadata.type,
+				lastModified: metadata.lastModified?.toISOString(),
+			};
+		}
+
+		// Download file content
+		const s3File = s3Client.file(args.filename);
+
+		const fileContent = await tui.spinner({
+			message: `Downloading ${args.filename} from ${args.name}`,
+			clearOnSuccess: true,
+			callback: async () => {
+				return Buffer.from(await s3File.arrayBuffer());
+			},
+		});
+
+		// Write to output or STDOUT
+		const outputPath = args.output || '-';
+
+		if (outputPath === '-') {
+			// Write to STDOUT
+			// When outputting to STDOUT in JSON mode, we can't mix file content with JSON
+			if (options.json) {
+				tui.fatal(
+					'Cannot use --json with STDOUT output. Use --metadata to get JSON metadata, or specify an output file.',
+					ErrorCode.INVALID_ARGUMENT
+				);
+			}
+
+			process.stdout.write(fileContent);
+		} else {
+			// Write to file
+			await Bun.write(outputPath, fileContent);
+			if (!options.json) {
+				tui.success(
+					`Downloaded ${tui.bold(args.filename)} to ${tui.bold(outputPath)} (${fileContent.length} bytes)`
+				);
+			}
+		}
+
+		return {
+			success: true,
+			bucket: args.name,
+			filename: args.filename,
+			size: fileContent.length,
+			contentType: s3File.type,
+			lastModified: undefined,
+		};
+	},
+});

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

@@ -0,0 +1,106 @@
+import { z } from 'zod';
+import { listResources } from '@agentuity/server';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCatalystAPIClient } from '../../../config';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+
+const StorageGetResponseSchema = z.object({
+	bucket_name: z.string().describe('Storage bucket name'),
+	access_key: z.string().optional().describe('S3 access key'),
+	secret_key: z.string().optional().describe('S3 secret key'),
+	region: z.string().optional().describe('S3 region'),
+	endpoint: z.string().optional().describe('S3 endpoint URL'),
+});
+
+export const getSubcommand = createSubcommand({
+	name: 'get',
+	aliases: ['show'],
+	description: 'Show details about a specific storage bucket',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true, org: true, region: true },
+	idempotent: true,
+	examples: [
+		{
+			command: `${getCommand('cloud storage get')} my-bucket`,
+			description: 'Get bucket details',
+		},
+		{
+			command: `${getCommand('cloud storage show')} my-bucket`,
+			description: 'Show bucket information',
+		},
+		{
+			command: `${getCommand('cloud storage get')} my-bucket --show-credentials`,
+			description: 'Get bucket with credentials',
+		},
+	],
+	schema: {
+		args: z.object({
+			name: z.string().describe('Bucket name'),
+		}),
+		options: z.object({
+			showCredentials: z
+				.boolean()
+				.optional()
+				.describe(
+					'Show credentials in plain text (default: masked in terminal, unmasked in JSON)'
+				),
+		}),
+		response: StorageGetResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { logger, args, opts, options, orgId, region, config, auth } = ctx;
+
+		const catalystClient = getCatalystAPIClient(config, logger, auth);
+
+		const resources = await tui.spinner({
+			message: `Fetching storage bucket ${args.name}`,
+			clearOnSuccess: true,
+			callback: async () => {
+				return listResources(catalystClient, orgId, region);
+			},
+		});
+
+		const bucket = resources.s3.find((s3) => s3.bucket_name === args.name);
+
+		if (!bucket) {
+			tui.fatal(`Storage bucket '${args.name}' not found`, ErrorCode.RESOURCE_NOT_FOUND);
+		}
+
+		// Mask credentials in terminal output by default, unless --show-credentials is passed
+		const shouldShowCredentials = opts.showCredentials === true;
+		const shouldMask = !options.json && !shouldShowCredentials;
+
+		if (!options.json) {
+			console.log(tui.bold('Bucket Name: ') + bucket.bucket_name);
+			if (bucket.access_key) {
+				const displayAccessKey = shouldMask
+					? tui.maskSecret(bucket.access_key)
+					: bucket.access_key;
+				console.log(tui.bold('Access Key:  ') + displayAccessKey);
+			}
+			if (bucket.secret_key) {
+				const displaySecretKey = shouldMask
+					? tui.maskSecret(bucket.secret_key)
+					: bucket.secret_key;
+				console.log(tui.bold('Secret Key:  ') + displaySecretKey);
+			}
+			if (bucket.region) {
+				console.log(tui.bold('Region:      ') + bucket.region);
+			}
+			if (bucket.endpoint) {
+				console.log(tui.bold('Endpoint:    ') + bucket.endpoint);
+			}
+		}
+
+		return {
+			bucket_name: bucket.bucket_name,
+			access_key: bucket.access_key ?? undefined,
+			secret_key: bucket.secret_key ?? undefined,
+			region: bucket.region ?? undefined,
+			endpoint: bucket.endpoint ?? undefined,
+		};
+	},
+});

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

@@ -0,0 +1,30 @@
+import { createCommand } from '../../../types';
+import { createSubcommand } from './create';
+import { listSubcommand } from './list';
+import { deleteSubcommand } from './delete';
+import { getSubcommand } from './get';
+import { uploadSubcommand } from './upload';
+import { downloadSubcommand } from './download';
+import { getCommand } from '../../../command-prefix';
+
+export const storageCommand = createCommand({
+	name: 'storage',
+	aliases: ['s3'],
+	description: 'Manage storage resources',
+	tags: ['slow', 'requires-auth', 'requires-deployment'],
+	examples: [
+		{ command: getCommand('cloud storage list'), description: 'List all storage resources' },
+		{
+			command: getCommand('cloud storage upload ./file.txt'),
+			description: 'Upload file to storage',
+		},
+	],
+	subcommands: [
+		createSubcommand,
+		listSubcommand,
+		getSubcommand,
+		uploadSubcommand,
+		downloadSubcommand,
+		deleteSubcommand,
+	],
+});