@agentuity/cli 1.0.15 → 1.0.17

package/src/cmd/cloud/sandbox/snapshot/generate.ts

@@ -35,6 +35,12 @@ description: My sandbox snapshot
 #   - ffmpeg
 #   - imagemagick=8:6.9*
 
+# Optional: npm/bun packages to install globally
+# Installed via 'bun install -g' at sandbox startup
+# packages:
+#   - opencode-ai
+#   - typescript
+
 # Optional: Files to include from the build context directory
 # Supports glob patterns and negative patterns (prefix with !)
 # Files are placed in /home/agentuity/ in the sandbox
@@ -68,6 +74,7 @@ const TEMPLATE_JSON = {
 	name: 'my-snapshot',
 	description: 'My sandbox snapshot',
 	dependencies: ['curl'],
+	packages: ['opencode-ai'],
 	files: ['src/**', '*.js', '!**/*.test.js'],
 	env: {
 		NODE_ENV: 'production',

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

@@ -1,10 +1,11 @@
 import { z } from 'zod';
-import { createResources } from '@agentuity/server';
+import { createResources, APIError, validateBucketName } from '@agentuity/server';
 import { createSubcommand as defineSubcommand } 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 { addResourceEnvVars } from '../../../env-util';
 
 export const createSubcommand = defineSubcommand({
@@ -23,6 +24,10 @@ export const createSubcommand = defineSubcommand({
 			command: getCommand('cloud storage new'),
 			description: 'Alias for "cloud storage create" (shorthand "new")',
 		},
+		{
+			command: getCommand('cloud storage create --name my-bucket'),
+			description: 'Create a new cloud storage bucket with a custom name',
+		},
 		{
 			command: getCommand('--dry-run cloud storage create'),
 			description: 'Dry-run: display what would be created without making changes',
@@ -30,6 +35,7 @@ export const createSubcommand = defineSubcommand({
 	],
 	schema: {
 		options: z.object({
+			name: z.string().optional().describe('Custom bucket name'),
 			description: z.string().optional().describe('Optional description for the bucket'),
 		}),
 		response: z.object({
@@ -41,9 +47,22 @@ export const createSubcommand = defineSubcommand({
 	async handler(ctx) {
 		const { logger, orgId, region, auth, options, opts } = ctx;
 
+		// Validate bucket name if provided
+		if (opts.name) {
+			const validation = validateBucketName(opts.name);
+			if (!validation.valid) {
+				tui.fatal(validation.error!, ErrorCode.INVALID_ARGUMENT);
+			}
+		}
+
 		// Handle dry-run mode
 		if (isDryRunMode(options)) {
-			const message = `Would create storage bucket in region: ${region}`;
+			let message = opts.name
+				? `Would create storage bucket with name: ${opts.name} in region: ${region}`
+				: `Would create storage bucket in region: ${region}`;
+			if (opts.description) {
+				message += ` with description: "${opts.description}"`;
+			}
 			outputDryRun(message, options);
 			if (!options.json) {
 				tui.newline();
@@ -51,41 +70,57 @@ export const createSubcommand = defineSubcommand({
 			}
 			return {
 				success: false,
-				name: 'dry-run-bucket',
+				name: opts.name || 'dry-run-bucket',
 			};
 		}
 
 		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
-		const created = await tui.spinner({
-			message: `Creating storage in ${region}`,
-			clearOnSuccess: true,
-			callback: async () => {
-				return createResources(catalystClient, orgId, region!, [
-					{ type: 's3', description: opts.description },
-				]);
-			},
-		});
+		try {
+			const created = await tui.spinner({
+				message: `Creating storage in ${region}`,
+				clearOnSuccess: true,
+				callback: async () => {
+					return createResources(catalystClient, orgId, region!, [
+						{ type: 's3', name: opts.name, description: opts.description },
+					]);
+				},
+			});
+
+			const resource = created[0];
+			if (resource) {
+				// Write environment variables to .env if running inside a project
+				if (ctx.projectDir && resource.env && Object.keys(resource.env).length > 0) {
+					await addResourceEnvVars(ctx.projectDir, resource.env);
+					if (!options.json) {
+						tui.info('Environment variables written to .env');
+					}
+				}
 
-		const resource = created[0];
-		if (resource) {
-			// Write environment variables to .env if running inside a project
-			if (ctx.projectDir && resource.env && Object.keys(resource.env).length > 0) {
-				await addResourceEnvVars(ctx.projectDir, resource.env);
 				if (!options.json) {
-					tui.info('Environment variables written to .env');
+					tui.success(`Created storage: ${tui.bold(resource.name)}`);
 				}
+				return {
+					success: true,
+					name: resource.name,
+				};
+			} else {
+				tui.fatal('Failed to create storage');
 			}
-
-			if (!options.json) {
-				tui.success(`Created storage: ${tui.bold(resource.name)}`);
+		} catch (ex) {
+			if (ex instanceof APIError) {
+				if (ex.status === 409) {
+					const bucketName = opts.name || 'auto-generated';
+					tui.fatal(
+						`bucket with the name "${bucketName}" already exists. Use another name or don't specify --name for a unique name to be generated automatically.`,
+						ErrorCode.INVALID_ARGUMENT
+					);
+				}
+				if (ex.status === 400) {
+					tui.fatal(ex.message || 'invalid bucket name', ErrorCode.INVALID_ARGUMENT);
+				}
 			}
-			return {
-				success: true,
-				name: resource.name,
-			};
-		} else {
-			tui.fatal('Failed to create storage');
+			throw ex;
 		}
 	},
 });

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

@@ -14,7 +14,7 @@ import { getResourceInfo, setResourceInfo, deleteResourceRegion } from '../../..
 export const deleteSubcommand = createSubcommand({
 	name: 'delete',
 	aliases: ['rm', 'del', 'remove'],
-	description: 'Delete a storage resource or file',
+	description: 'Delete a storage resource, file, or folder',
 	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth', 'requires-deployment'],
 	idempotent: false,
 	requires: { auth: true },
@@ -32,6 +32,10 @@ export const deleteSubcommand = createSubcommand({
 			command: getCommand('cloud storage delete'),
 			description: 'Interactive selection to delete a bucket',
 		},
+		{
+			command: getCommand('cloud storage delete my-bucket path/to/folder'),
+			description: 'Delete a folder and all its contents from a bucket',
+		},
 		{
 			command: getCommand('--dry-run cloud storage delete my-bucket'),
 			description: 'Dry-run: show what would be deleted without making changes',
@@ -48,6 +52,7 @@ export const deleteSubcommand = createSubcommand({
 		response: z.object({
 			success: z.boolean().describe('Whether deletion succeeded'),
 			name: z.string().describe('Deleted bucket or file name'),
+			count: z.number().optional().describe('Number of files deleted (for folder deletion)'),
 		}),
 	},
 
@@ -116,7 +121,7 @@ export const deleteSubcommand = createSubcommand({
 			bucketName = response.bucket;
 		}
 
-		// If filename is provided, delete the file from the bucket
+		// If filename is provided, delete the file or folder from the bucket
 		if (args.filename) {
 			const bucket = resources.s3.find((s3) => s3.bucket_name === bucketName);
 
@@ -131,22 +136,143 @@ export const deleteSubcommand = createSubcommand({
 				);
 			}
 
+			const s3Client = createS3Client({
+				endpoint: bucket.endpoint,
+				access_key: bucket.access_key,
+				secret_key: bucket.secret_key,
+				region: bucket.region,
+			});
+
+			const filePath = args.filename;
+
+			// Check if path represents a folder by listing objects under it
+			const folderPrefix = filePath.endsWith('/') ? filePath : filePath + '/';
+			const folderContents: Array<{ key: string }> = [];
+			let continuationToken: string | undefined;
+			let isTruncated = false;
+
+			do {
+				const folderResult = await s3Client.list({
+					prefix: folderPrefix,
+					...(continuationToken ? { continuationToken } : {}),
+				});
+				if (folderResult.contents) {
+					folderContents.push(...folderResult.contents);
+				}
+				continuationToken = folderResult.nextContinuationToken;
+				isTruncated = folderResult.isTruncated ?? false;
+			} while (isTruncated);
+
+			if (folderContents.length > 0) {
+				// Path is a folder — recursive delete
+				const keysToDelete = folderContents.map((obj: { key: string }) => obj.key);
+
+				// Handle dry-run mode
+				if (isDryRunMode(options)) {
+					outputDryRun(
+						`Would delete ${keysToDelete.length} file${keysToDelete.length === 1 ? '' : 's'} under ${folderPrefix} from bucket ${bucketName}`,
+						options
+					);
+					if (!options.json) {
+						tui.newline();
+						tui.info('[DRY RUN] Folder deletion skipped');
+					}
+					return { success: false, name: filePath, count: keysToDelete.length };
+				}
+
+				// Confirm
+				if (!opts.confirm) {
+					tui.warning(
+						`You are about to delete ${tui.bold(String(keysToDelete.length))} file${keysToDelete.length === 1 ? '' : 's'} under folder: ${tui.bold(folderPrefix)} 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 folder and all its contents?',
+						initial: false,
+					});
+					if (!confirm.confirm) {
+						tui.info('Deletion cancelled');
+						return { success: false, name: filePath };
+					}
+				}
+
+				// Delete all files
+				await tui.spinner({
+					message: `Deleting ${keysToDelete.length} file${keysToDelete.length === 1 ? '' : 's'} under ${folderPrefix} from ${bucketName}`,
+					clearOnSuccess: true,
+					callback: async () => {
+						const errors: Array<{ key: string; error: string }> = [];
+						for (const key of keysToDelete) {
+							try {
+								await s3Client.delete(key);
+							} catch (err) {
+								errors.push({
+									key,
+									error: err instanceof Error ? err.message : String(err),
+								});
+							}
+						}
+						if (errors.length > 0) {
+							const failedKeys = errors.map((e) => e.key).join(', ');
+							throw new Error(
+								`Failed to delete ${errors.length} file${errors.length === 1 ? '' : 's'}: ${failedKeys}`
+							);
+						}
+					},
+				});
+
+				// Also delete the exact file if it exists (handles file+folder name conflicts)
+				// Skip if filePath was already deleted as part of folder contents (e.g., trailing-slash folder markers)
+				if (!keysToDelete.includes(filePath)) {
+					const exactFileCheck = await s3Client.list({ prefix: filePath });
+					const exactFile = (exactFileCheck.contents || []).find(
+						(obj: { key: string }) => obj.key === filePath
+					);
+					if (exactFile) {
+						await s3Client.delete(filePath);
+						keysToDelete.push(filePath);
+					}
+				}
+
+				if (!options.json) {
+					tui.success(
+						`Deleted ${tui.bold(String(keysToDelete.length))} file${keysToDelete.length === 1 ? '' : 's'} under ${tui.bold(folderPrefix)} from ${tui.bold(bucketName)}`
+					);
+				}
+
+				return { success: true, name: filePath, count: keysToDelete.length };
+			}
+
+			// Not a folder — check if exact file exists
+			const fileResult = await s3Client.list({ prefix: filePath });
+			const exactMatch = (fileResult.contents || []).find(
+				(obj: { key: string }) => obj.key === filePath
+			);
+
+			if (!exactMatch) {
+				tui.fatal(
+					`No file or folder found at '${filePath}' in bucket '${bucketName}'`,
+					ErrorCode.RESOURCE_NOT_FOUND
+				);
+			}
+
 			// Handle dry-run mode
 			if (isDryRunMode(options)) {
-				outputDryRun(`Would delete file ${args.filename} from bucket ${bucketName}`, options);
+				outputDryRun(`Would delete file ${filePath} from bucket ${bucketName}`, options);
 				if (!options.json) {
 					tui.newline();
 					tui.info('[DRY RUN] File deletion skipped');
 				}
 				return {
 					success: false,
-					name: args.filename,
+					name: filePath,
 				};
 			}
 
 			if (!opts.confirm) {
 				tui.warning(
-					`You are about to delete file: ${tui.bold(args.filename)} from bucket: ${tui.bold(bucketName)}`
+					`You are about to delete file: ${tui.bold(filePath)} from bucket: ${tui.bold(bucketName)}`
 				);
 
 				const confirm = await enquirer.prompt<{ confirm: boolean }>({
@@ -158,32 +284,25 @@ export const deleteSubcommand = createSubcommand({
 
 				if (!confirm.confirm) {
 					tui.info('Deletion cancelled');
-					return { success: false, name: args.filename };
+					return { success: false, name: filePath };
 				}
 			}
 
-			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}`,
+				message: `Deleting ${filePath} from ${bucketName}`,
 				clearOnSuccess: true,
 				callback: async () => {
-					await s3Client.delete(args.filename!);
+					await s3Client.delete(filePath);
 				},
 			});
 
 			if (!options.json) {
-				tui.success(`Deleted file: ${tui.bold(args.filename)} from ${tui.bold(bucketName)}`);
+				tui.success(`Deleted file: ${tui.bold(filePath)} from ${tui.bold(bucketName)}`);
 			}
 
 			return {
 				success: true,
-				name: args.filename,
+				name: filePath,
 			};
 		}