@agentuity/cli 1.0.29 → 1.0.31

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

@@ -0,0 +1,238 @@
+import { z } from 'zod';
+import {
+	getBucketConfig,
+	updateBucketConfig,
+	deleteBucketConfig,
+	BucketConfigResponseError,
+	listOrgResources,
+	type BucketConfigUpdate,
+	type BucketConfig,
+	StorageTierSchema,
+} from '@agentuity/server';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCatalystAPIClient, getGlobalCatalystAPIClient } from '../../../config';
+import { getCommand } from '../../../command-prefix';
+import { getResourceInfo, setResourceInfo } from '../../../cache';
+
+function displayConfig(config: BucketConfig) {
+	tui.newline();
+	console.log(tui.bold('Bucket:          ') + config.bucket_name);
+	console.log(
+		tui.bold('Storage Tier:    ') + (config.storage_tier ?? tui.muted('default'))
+	);
+	console.log(
+		tui.bold('TTL:             ') +
+			(config.ttl != null ? `${config.ttl}s` : tui.muted('default'))
+	);
+	console.log(
+		tui.bold('Public:          ') +
+			(config.public != null ? String(config.public) : tui.muted('default'))
+	);
+	console.log(
+		tui.bold('Cache Control:   ') + (config.cache_control ?? tui.muted('default'))
+	);
+
+	if (config.cors) {
+		console.log(tui.bold('CORS:'));
+		if (config.cors.allowed_origins?.length) {
+			console.log('  Origins: ' + config.cors.allowed_origins.join(', '));
+		}
+		if (config.cors.allowed_methods?.length) {
+			console.log('  Methods: ' + config.cors.allowed_methods.join(', '));
+		}
+		if (config.cors.allowed_headers?.length) {
+			console.log('  Headers: ' + config.cors.allowed_headers.join(', '));
+		}
+		if (config.cors.expose_headers?.length) {
+			console.log('  Expose:  ' + config.cors.expose_headers.join(', '));
+		}
+		if (config.cors.max_age_seconds != null) {
+			console.log('  Max Age: ' + config.cors.max_age_seconds + 's');
+		}
+	} else {
+		console.log(tui.bold('CORS:            ') + tui.muted('default'));
+	}
+
+	if (config.additional_headers && Object.keys(config.additional_headers).length > 0) {
+		console.log(tui.bold('Headers:'));
+		for (const [key, value] of Object.entries(config.additional_headers)) {
+			console.log(`  ${key}: ${value}`);
+		}
+	} else {
+		console.log(tui.bold('Headers:         ') + tui.muted('default'));
+	}
+	tui.newline();
+}
+
+export const configSubcommand = createSubcommand({
+	name: 'config',
+	description: 'View or update bucket configuration',
+	tags: ['slow', 'requires-auth'],
+	requires: { auth: true },
+	optional: { org: true },
+	idempotent: true,
+	examples: [
+		{
+			command: `${getCommand('cloud storage config')} my-bucket`,
+			description: 'View bucket configuration',
+		},
+		{
+			command: `${getCommand('cloud storage config')} my-bucket --ttl 3600 --public`,
+			description: 'Update bucket TTL and make it public',
+		},
+		{
+			command: `${getCommand('cloud storage config')} my-bucket --storage-tier ARCHIVE`,
+			description: 'Change the storage tier',
+		},
+		{
+			command: `${getCommand('cloud storage config')} my-bucket --reset`,
+			description: 'Reset all configuration to system defaults',
+		},
+	],
+	schema: {
+		args: z.object({
+			name: z.string().describe('The name of the storage bucket'),
+		}),
+		options: z.object({
+			reset: z.boolean().optional().describe('Reset all configuration to system defaults'),
+			storageTier: StorageTierSchema.optional().describe('Storage tier'),
+			ttl: z.coerce.number().optional().describe('Object TTL in seconds (0 to clear)'),
+			public: z.boolean().optional().describe('Make bucket publicly accessible'),
+			cacheControl: z.string().optional().describe('Cache-Control header value'),
+			cors: z.string().optional().describe('CORS configuration as JSON string'),
+			additionalHeaders: z
+				.string()
+				.optional()
+				.describe('Additional headers as JSON key-value pairs'),
+		}),
+		response: z.object({
+			bucket_name: z.string(),
+			storage_tier: z.string().nullable().optional(),
+			ttl: z.number().nullable().optional(),
+			public: z.boolean().nullable().optional(),
+			cache_control: z.string().nullable().optional(),
+			cors: z.any().nullable().optional(),
+			additional_headers: z.record(z.string(), z.string()).nullable().optional(),
+		}),
+	},
+
+	async handler(ctx) {
+		const { logger, args, opts, options, auth, config } = ctx;
+		const { name: bucketName } = args;
+
+		const profileName = config?.name ?? 'production';
+		const catalystClient = await getGlobalCatalystAPIClient(logger, auth, profileName);
+
+		// Look up bucket to get cloud_region
+		const cachedInfo = await getResourceInfo('bucket', profileName, bucketName);
+		const orgId = ctx.orgId ?? cachedInfo?.orgId;
+
+		const resources = await tui.spinner({
+			message: 'Looking up bucket...',
+			clearOnSuccess: true,
+			callback: () => listOrgResources(catalystClient, { type: 's3', orgId }),
+		});
+
+		const bucket = resources.s3.find((s3) => s3.bucket_name === bucketName);
+		if (!bucket) {
+			throw new BucketConfigResponseError({ message: `Bucket "${bucketName}" not found` });
+		}
+
+		// Cache the bucket info for future lookups
+		if (bucket.cloud_region && bucket.org_id) {
+			await setResourceInfo(
+				'bucket',
+				profileName,
+				bucket.bucket_name,
+				bucket.cloud_region,
+				bucket.org_id
+			);
+		}
+
+		if (!bucket.cloud_region) {
+			throw new BucketConfigResponseError({
+				message: `Bucket "${bucketName}" is missing region information`,
+			});
+		}
+
+		// Create regional client for bucket config operations (orgId required for CLI auth)
+		const regionalClient = getCatalystAPIClient(logger, auth, bucket.cloud_region, bucket.org_id);
+
+		// Handle --reset flag (DELETE)
+		if (opts.reset) {
+			await tui.spinner({
+				message: 'Resetting bucket configuration...',
+				clearOnSuccess: true,
+				callback: () => deleteBucketConfig(regionalClient, bucketName),
+			});
+			if (!options.json) {
+				tui.success(`Configuration reset to defaults for bucket "${bucketName}"`);
+			}
+			return { bucket_name: bucketName };
+		}
+
+		// Check if any update flags are present
+		const hasUpdateFlags =
+			opts.storageTier !== undefined ||
+			opts.ttl !== undefined ||
+			opts.public !== undefined ||
+			opts.cacheControl !== undefined ||
+			opts.cors !== undefined ||
+			opts.additionalHeaders !== undefined;
+
+		if (hasUpdateFlags) {
+			// Build update payload
+			const update: BucketConfigUpdate = {};
+
+			if (opts.storageTier !== undefined) update.storage_tier = opts.storageTier;
+			if (opts.ttl !== undefined) update.ttl = opts.ttl === 0 ? null : opts.ttl;
+			if (opts.public !== undefined) update.public = opts.public;
+			if (opts.cacheControl !== undefined) update.cache_control = opts.cacheControl;
+
+			// Parse JSON flags
+			if (opts.cors !== undefined) {
+				try {
+					update.cors = JSON.parse(opts.cors);
+				} catch {
+					throw new BucketConfigResponseError({
+						message: 'Invalid JSON for --cors flag',
+					});
+				}
+			}
+			if (opts.additionalHeaders !== undefined) {
+				try {
+					update.additional_headers = JSON.parse(opts.additionalHeaders);
+				} catch {
+					throw new BucketConfigResponseError({
+						message: 'Invalid JSON for --additionalHeaders flag',
+					});
+				}
+			}
+
+			const result = await tui.spinner({
+				message: 'Updating bucket configuration...',
+				clearOnSuccess: true,
+				callback: () => updateBucketConfig(regionalClient, bucketName, update),
+			});
+
+			if (!options.json) {
+				displayConfig(result);
+				tui.success(`Configuration updated for bucket "${bucketName}"`);
+			}
+			return result;
+		}
+
+		// No update flags — GET and display
+		const getResult = await tui.spinner({
+			message: 'Fetching bucket configuration...',
+			clearOnSuccess: true,
+			callback: () => getBucketConfig(regionalClient, bucketName),
+		});
+
+		if (!options.json) {
+			displayConfig(getResult);
+		}
+		return getResult;
+	},
+});

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

@@ -1,4 +1,5 @@
 import { createCommand } from '../../../types';
+import { configSubcommand } from './config';
 import { createSubcommand } from './create';
 import { listSubcommand } from './list';
 import { deleteSubcommand } from './delete';
@@ -20,6 +21,7 @@ export const storageCommand = createCommand({
 		},
 	],
 	subcommands: [
+		configSubcommand,
 		createSubcommand,
 		listSubcommand,
 		getSubcommand,

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

@@ -23,6 +23,9 @@ const StorageListResponseSchema = z.object({
 				bucket_type: z.string().optional().describe('Bucket type (user or snapshots)'),
 				internal: z.boolean().optional().describe('Whether this is a system-managed bucket'),
 				description: z.string().optional().describe('Optional description of the bucket'),
+				object_count: z.number().int().optional().describe('Number of objects in this bucket'),
+				total_size: z.number().int().optional().describe('Total size of objects in bytes'),
+				last_event_at: z.string().optional().describe('Last activity timestamp'),
 			})
 		)
 		.optional()
@@ -256,6 +259,18 @@ export const listSubcommand = createSubcommand({
 					}
 					if (s3.region) console.log(` Region:     ${tui.muted(s3.region)}`);
 					if (s3.endpoint) console.log(` Endpoint:   ${tui.muted(s3.endpoint)}`);
+					if (s3.object_count != null) {
+						const sizeStr = s3.total_size != null ? tui.formatBytes(s3.total_size) : 'unknown';
+						console.log(` Objects:    ${tui.muted(`${s3.object_count.toLocaleString()} (${sizeStr})`)}`);
+					}
+					if (s3.last_event_at) {
+						const date = new Date(s3.last_event_at);
+						if (Number.isNaN(date.getTime())) {
+							console.log(` Activity:   ${tui.muted('unknown')}`);
+						} else {
+							console.log(` Activity:   ${tui.muted(date.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric', hour: '2-digit', minute: '2-digit' }))}`);
+						}
+					}
 					tui.newline();
 				}
 			}
@@ -274,6 +289,9 @@ export const listSubcommand = createSubcommand({
 				bucket_type: s3.bucket_type,
 				internal: s3.internal,
 				description: s3.description ?? undefined,
+				object_count: s3.object_count ?? undefined,
+				total_size: s3.total_size ?? undefined,
+				last_event_at: s3.last_event_at ?? undefined,
 			})),
 		};
 	},

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

@@ -5,7 +5,7 @@ import * as tui from '../../../tui';
 import { createStorageAdapter, parseMetadataFlag, cacheTaskId } from './util';
 import { getCommand } from '../../../command-prefix';
 import { whoami } from '@agentuity/server';
-import type { TaskPriority, TaskStatus, TaskType } from '@agentuity/core';
+import type { TaskPriority, TaskStatus, TaskType, UserType } from '@agentuity/core';
 import { getCachedUserInfo, setCachedUserInfo } from '../../../cache';
 import { defaultProfileName } from '../../../config';
 
@@ -70,6 +70,10 @@ export const createSubcommand = createCommand({
 				.min(1)
 				.optional()
 				.describe('the display name of the creator (used with --created-id)'),
+			createdType: z
+				.enum(['human', 'agent'])
+				.optional()
+				.describe('the type of the creator - human user or AI agent (default: human)'),
 			projectId: z.string().optional().describe('project ID to associate with the task'),
 			projectName: z
 				.string()
@@ -101,18 +105,23 @@ export const createSubcommand = createCommand({
 
 		// Resolve creator info
 		const createdId = opts.createdId ?? ctx.auth.userId;
-		let creator: { id: string; name: string } | undefined;
-		if (opts.createdId && opts.createdName) {
-			// Explicit creator with name
-			creator = { id: opts.createdId, name: opts.createdName };
-		} else if (!opts.createdId) {
+		const createdType = (opts.createdType as UserType) ?? 'human';
+		let creator: { id: string; name: string; type?: UserType } | undefined;
+		if (opts.createdId) {
+			// Explicit creator — use createdId as name fallback (like project pattern)
+			creator = {
+				id: opts.createdId,
+				name: opts.createdName ?? opts.createdId,
+				type: createdType,
+			};
+		} else {
 			// Using auth userId — check cache first, then fall back to whoami API call
 			const profileName = ctx.config?.name ?? defaultProfileName;
 			const cached = getCachedUserInfo(profileName);
 			if (cached) {
 				const name = [cached.firstName, cached.lastName].filter(Boolean).join(' ');
 				if (name) {
-					creator = { id: createdId, name };
+					creator = { id: createdId, name, type: createdType };
 				}
 			} else {
 				// Fetch from API and cache
@@ -120,7 +129,7 @@ export const createSubcommand = createCommand({
 					const user = await whoami(ctx.apiClient);
 					const name = [user.firstName, user.lastName].filter(Boolean).join(' ');
 					if (name) {
-						creator = { id: createdId, name };
+						creator = { id: createdId, name, type: createdType };
 					}
 					setCachedUserInfo(profileName, createdId, user.firstName, user.lastName);
 				} catch {

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

@@ -0,0 +1,331 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createStorageAdapter } from './util';
+import { getCommand } from '../../../command-prefix';
+import { isDryRunMode, outputDryRun } from '../../../explain';
+import type { TaskPriority, TaskStatus, TaskType, BatchDeletedTask } from '@agentuity/core';
+
+const DURATION_UNITS: Record<string, number> = {
+	s: 1000,
+	m: 60 * 1000,
+	h: 60 * 60 * 1000,
+	d: 24 * 60 * 60 * 1000,
+	w: 7 * 24 * 60 * 60 * 1000,
+};
+
+/**
+ * Parse a human-friendly duration string (e.g. "30s", "7d", "24h", "30m", "2w")
+ * into milliseconds. Exported for testing.
+ */
+export function parseDuration(duration: string): number {
+	const match = duration.match(/^(\d+)([smhdw])$/);
+	if (!match) {
+		tui.fatal(
+			`Invalid duration format: "${duration}". Use a number followed by s (seconds), m (minutes), h (hours), d (days), or w (weeks). Examples: 30s, 30m, 24h, 7d, 2w`
+		);
+		// tui.fatal exits, but TypeScript doesn't know that
+		throw new Error('unreachable');
+	}
+	const value = parseInt(match[1]!, 10);
+	const unit = match[2]!;
+	const ms = DURATION_UNITS[unit];
+	if (!ms) {
+		tui.fatal(`Unknown duration unit: "${unit}"`);
+		throw new Error('unreachable');
+	}
+	return value * ms;
+}
+
+function truncate(s: string, max: number): string {
+	if (s.length <= max) return s;
+	return `${s.slice(0, max - 1)}…`;
+}
+
+const TaskDeleteResponseSchema = z.object({
+	success: z.boolean().describe('Whether the operation succeeded'),
+	deleted: z
+		.array(
+			z.object({
+				id: z.string().describe('Deleted task ID'),
+				title: z.string().describe('Deleted task title'),
+			})
+		)
+		.describe('List of deleted tasks'),
+	count: z.number().describe('Number of tasks deleted'),
+	durationMs: z.number().describe('Operation duration in milliseconds'),
+	dryRun: z.boolean().optional().describe('Whether this was a dry run'),
+	message: z.string().optional().describe('Status message'),
+});
+
+export const deleteSubcommand = createCommand({
+	name: 'delete',
+	aliases: ['del', 'rm'],
+	description: 'Soft-delete a task by ID or batch-delete tasks by filter',
+	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud task delete task_abc123'),
+			description: 'Delete a single task by ID',
+		},
+		{
+			command: getCommand('cloud task delete --status closed --older-than 7d'),
+			description: 'Delete closed tasks older than 7 days',
+		},
+		{
+			command: getCommand('cloud task delete --status done --limit 10 --dry-run'),
+			description: 'Preview which done tasks would be deleted (dry run)',
+		},
+		{
+			command: getCommand('cloud task delete --status cancelled --confirm'),
+			description: 'Delete all cancelled tasks without confirmation prompt',
+		},
+	],
+	schema: {
+		args: z.object({
+			id: z.string().optional().describe('Task ID to delete (for single delete)'),
+		}),
+		options: z.object({
+			status: z
+				.enum(['open', 'in_progress', 'done', 'closed', 'cancelled'])
+				.optional()
+				.describe('filter batch delete by status'),
+			type: z
+				.enum(['epic', 'feature', 'enhancement', 'bug', 'task'])
+				.optional()
+				.describe('filter batch delete by type'),
+			priority: z
+				.enum(['high', 'medium', 'low', 'none'])
+				.optional()
+				.describe('filter batch delete by priority'),
+			olderThan: z
+				.string()
+				.optional()
+				.describe('filter batch delete by age (e.g. 30s, 7d, 24h, 2w)'),
+			parentId: z.string().optional().describe('filter batch delete by parent task ID'),
+			createdId: z.string().optional().describe('filter batch delete by creator ID'),
+			limit: z.coerce
+				.number()
+				.int()
+				.min(1)
+				.max(200)
+				.default(50)
+				.describe('max tasks to delete in batch mode (default: 50, max: 200)'),
+			confirm: z.boolean().optional().default(false).describe('skip confirmation prompt'),
+		}),
+		response: TaskDeleteResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const started = Date.now();
+		const storage = await createStorageAdapter(ctx);
+
+		// Determine mode: single delete or batch delete
+		const isSingleDelete = !!args.id;
+		const hasFilters =
+			opts.status || opts.type || opts.priority || opts.olderThan || opts.parentId || opts.createdId;
+
+		if (!isSingleDelete && !hasFilters) {
+			tui.fatal(
+				'Provide a task ID for single delete, or use --status, --type, --priority, --older-than, --parent-id, or --created-id for batch delete.'
+			);
+		}
+
+		if (isSingleDelete && hasFilters) {
+			tui.fatal(
+				'Cannot combine task ID with filter options. Use either single delete (by ID) or batch delete (by filters).'
+			);
+		}
+
+		// ── Single delete mode ──────────────────────────────────────────────
+		if (isSingleDelete) {
+			if (isDryRunMode(options)) {
+				outputDryRun(`Would soft-delete task: ${args.id}`, options);
+				return {
+					success: true,
+					deleted: [{ id: args.id!, title: '(dry run)' }],
+					count: 1,
+					durationMs: Date.now() - started,
+					dryRun: true,
+					message: 'Dry run — no tasks were deleted',
+				};
+			}
+
+			if (!opts.confirm) {
+				const confirmed = await tui.confirm(`Delete task "${args.id}"?`, false);
+				if (!confirmed) {
+					if (!options.json) tui.info('Cancelled');
+					return {
+						success: false,
+						deleted: [],
+						count: 0,
+						durationMs: Date.now() - started,
+						message: 'Cancelled',
+					};
+				}
+			}
+
+			const task = await storage.softDelete(args.id!);
+			const durationMs = Date.now() - started;
+
+			if (!options.json) {
+				tui.success(`Deleted task ${tui.bold(task.id)} (${task.title}) in ${durationMs}ms`);
+			}
+
+			return {
+				success: true,
+				deleted: [{ id: task.id, title: task.title }],
+				count: 1,
+				durationMs,
+			};
+		}
+
+		// ── Batch delete mode ───────────────────────────────────────────────
+		// Validate older-than format early (before calling the API)
+		if (opts.olderThan) {
+			parseDuration(opts.olderThan); // will fatal on invalid format
+		}
+
+		const batchParams = {
+			status: opts.status as TaskStatus | undefined,
+			type: opts.type as TaskType | undefined,
+			priority: opts.priority as TaskPriority | undefined,
+			parent_id: opts.parentId,
+			created_id: opts.createdId,
+			older_than: opts.olderThan,
+			limit: opts.limit,
+		};
+
+		// For dry-run and preview, first list what would be matched
+		// (we call batchDelete only when actually executing)
+		if (isDryRunMode(options) || !opts.confirm) {
+			// Use list() to preview matching tasks
+			const preview = await storage.list({
+				status: batchParams.status,
+				type: batchParams.type,
+				priority: batchParams.priority,
+				parent_id: batchParams.parent_id,
+				limit: batchParams.limit,
+				sort: 'created_at',
+				order: 'asc',
+			});
+
+			// Client-side filters for preview (server will apply these on actual delete)
+			let candidates = preview.tasks;
+			if (batchParams.created_id) {
+				candidates = candidates.filter(
+					(t: { created_id: string }) => t.created_id === batchParams.created_id
+				);
+			}
+			if (opts.olderThan) {
+				const durationMs = parseDuration(opts.olderThan);
+				const cutoff = new Date(Date.now() - durationMs);
+				candidates = candidates.filter(
+					(t: { created_at: string }) => new Date(t.created_at) < cutoff
+				);
+			}
+
+			if (candidates.length === 0) {
+				if (!options.json) tui.info('No tasks match the given filters');
+				return {
+					success: true,
+					deleted: [],
+					count: 0,
+					durationMs: Date.now() - started,
+					message: 'No matching tasks found',
+				};
+			}
+
+			// Show preview table
+			if (!options.json) {
+				tui.warning(
+					`Found ${candidates.length} ${tui.plural(candidates.length, 'task', 'tasks')} to delete:`
+				);
+				tui.newline();
+
+				const tableData = candidates.map(
+					(task: { id: string; title: string; status: string; type: string; created_at: string }) => ({
+						ID: tui.muted(truncate(task.id, 28)),
+						Title: truncate(task.title, 40),
+						Status: task.status,
+						Type: task.type,
+						Created: new Date(task.created_at).toLocaleDateString(),
+					})
+				);
+
+				tui.table(tableData, [
+					{ name: 'ID', alignment: 'left' },
+					{ name: 'Title', alignment: 'left' },
+					{ name: 'Status', alignment: 'left' },
+					{ name: 'Type', alignment: 'left' },
+					{ name: 'Created', alignment: 'left' },
+				]);
+				tui.newline();
+			}
+
+			// Dry-run: return preview without executing
+			if (isDryRunMode(options)) {
+				outputDryRun(
+					`Would soft-delete ${candidates.length} ${tui.plural(candidates.length, 'task', 'tasks')}`,
+					options
+				);
+				return {
+					success: true,
+					deleted: candidates.map(
+						(t: { id: string; title: string }): BatchDeletedTask => ({
+							id: t.id,
+							title: t.title,
+						})
+					),
+					count: candidates.length,
+					durationMs: Date.now() - started,
+					dryRun: true,
+					message: 'Dry run — no tasks were deleted',
+				};
+			}
+
+			// Confirmation prompt
+			if (!opts.confirm) {
+				const confirmed = await tui.confirm(
+					`Delete ${candidates.length} ${tui.plural(candidates.length, 'task', 'tasks')}?`,
+					false
+				);
+				if (!confirmed) {
+					if (!options.json) tui.info('Cancelled');
+					return {
+						success: false,
+						deleted: [],
+						count: 0,
+						durationMs: Date.now() - started,
+						message: 'Cancelled',
+					};
+				}
+			}
+		}
+
+		// Execute batch delete via server-side API
+		const result = await storage.batchDelete(batchParams);
+		const durationMs = Date.now() - started;
+
+		if (!options.json) {
+			if (result.count > 0) {
+				tui.success(
+					`Deleted ${result.count} ${tui.plural(result.count, 'task', 'tasks')} in ${durationMs}ms`
+				);
+			} else {
+				tui.info('No tasks matched the given filters');
+			}
+		}
+
+		return {
+			success: true,
+			deleted: result.deleted,
+			count: result.count,
+			durationMs,
+		};
+	},
+});
+
+export default deleteSubcommand;