@agentuity/cli 0.0.58 → 0.0.60

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

@@ -0,0 +1,154 @@
+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: [
+		`${getCommand('cloud storage download')} my-bucket file.txt`,
+		`${getCommand('cloud storage download')} my-bucket file.txt output.txt`,
+		`${getCommand('cloud storage download')} my-bucket file.txt - > output.txt`,
+		`${getCommand('cloud storage download')} my-bucket file.txt --metadata`,
+	],
+	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,97 @@
+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: [
+		`${getCommand('cloud storage get')} my-bucket`,
+		`${getCommand('cloud storage show')} my-bucket`,
+		`${getCommand('cloud storage get')} my-bucket --show-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,22 @@
+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';
+
+export const storageCommand = createCommand({
+	name: 'storage',
+	aliases: ['s3'],
+	description: 'Manage storage resources',
+	tags: ['slow', 'requires-auth', 'requires-deployment'],
+	subcommands: [
+		createSubcommand,
+		listSubcommand,
+		getSubcommand,
+		uploadSubcommand,
+		downloadSubcommand,
+		deleteSubcommand,
+	],
+});

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

@@ -0,0 +1,197 @@
+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';
+
+const StorageListResponseSchema = z.object({
+	buckets: z
+		.array(
+			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'),
+			})
+		)
+		.optional()
+		.describe('List of storage resources'),
+	files: z
+		.array(
+			z.object({
+				key: z.string().describe('File key/path'),
+				size: z.number().describe('File size in bytes'),
+				lastModified: z.string().describe('Last modified timestamp'),
+			})
+		)
+		.optional()
+		.describe('List of files in bucket'),
+});
+
+export const listSubcommand = createSubcommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List storage resources or files in a bucket',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true, org: true, region: true },
+	idempotent: true,
+	examples: [
+		getCommand('cloud storage list'),
+		getCommand('cloud storage list my-bucket'),
+		getCommand('cloud storage list my-bucket path/prefix'),
+		getCommand('--json cloud storage list'),
+		getCommand('cloud storage ls'),
+		getCommand('cloud storage list --show-credentials'),
+	],
+	schema: {
+		args: z.object({
+			name: z.string().optional().describe('Bucket name to list files from'),
+			prefix: z.string().optional().describe('Path prefix to filter files'),
+		}),
+		options: z.object({
+			showCredentials: z
+				.boolean()
+				.optional()
+				.describe(
+					'Show credentials in plain text (default: masked in terminal, unmasked in JSON)'
+				),
+		}),
+		response: StorageListResponseSchema,
+	},
+
+	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 for ${orgId} in ${region}`,
+			clearOnSuccess: true,
+			callback: async () => {
+				return listResources(catalystClient, orgId, region);
+			},
+		});
+
+		// If bucket name is provided, list files in the bucket
+		if (args.name) {
+			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
+				);
+			}
+
+			const s3Client = createS3Client({
+				endpoint: bucket.endpoint,
+				access_key: bucket.access_key,
+				secret_key: bucket.secret_key,
+				region: bucket.region,
+			});
+
+			const result = await tui.spinner({
+				message: `Listing files in ${args.name}${args.prefix ? ` with prefix ${args.prefix}` : ''}`,
+				clearOnSuccess: true,
+				callback: async () => {
+					return s3Client.list(
+						args.prefix
+							? {
+									prefix: args.prefix,
+								}
+							: null
+					);
+				},
+			});
+
+			const objects = result.contents || [];
+
+			if (!options.json) {
+				if (objects.length === 0) {
+					tui.info('No files found');
+				} else {
+					tui.info(
+						tui.bold(`Files in ${args.name}${args.prefix ? ` (prefix: ${args.prefix})` : ''}`)
+					);
+					tui.newline();
+					for (const obj of objects) {
+						console.log(
+							`${obj.key}  ${tui.muted(`(${obj.size} bytes, ${obj.lastModified})`)}`
+						);
+					}
+				}
+			}
+
+			return {
+				files: objects.map((obj) => {
+					const lastModified = obj.lastModified;
+					let lastModifiedStr = '';
+					if (typeof lastModified === 'string') {
+						lastModifiedStr = lastModified;
+					} else if (
+						lastModified &&
+						typeof lastModified === 'object' &&
+						'toISOString' in lastModified
+					) {
+						lastModifiedStr = (lastModified as Date).toISOString();
+					}
+					return {
+						key: obj.key,
+						size: obj.size ?? 0,
+						lastModified: lastModifiedStr,
+					};
+				}),
+			};
+		}
+
+		// Otherwise, list buckets
+		// 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) {
+			if (resources.s3.length === 0) {
+				tui.info('No storage buckets found');
+			} else {
+				tui.info(tui.bold('Storage'));
+				tui.newline();
+				for (const s3 of resources.s3) {
+					console.log(tui.bold(s3.bucket_name));
+					if (s3.access_key) {
+						const displayAccessKey = shouldMask
+							? tui.maskSecret(s3.access_key)
+							: s3.access_key;
+						console.log(` Access Key: ${tui.muted(displayAccessKey)}`);
+					}
+					if (s3.secret_key) {
+						const displaySecretKey = shouldMask
+							? tui.maskSecret(s3.secret_key)
+							: s3.secret_key;
+						console.log(` Secret Key: ${tui.muted(displaySecretKey)}`);
+					}
+					if (s3.region) console.log(` Region:     ${tui.muted(s3.region)}`);
+					if (s3.endpoint) console.log(` Endpoint:   ${tui.muted(s3.endpoint)}`);
+					tui.newline();
+				}
+			}
+		}
+
+		return {
+			buckets: resources.s3.map((s3) => ({
+				bucket_name: s3.bucket_name,
+				access_key: s3.access_key ?? undefined,
+				secret_key: s3.secret_key ?? undefined,
+				region: s3.region ?? undefined,
+				endpoint: s3.endpoint ?? undefined,
+			})),
+		};
+	},
+});

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

@@ -0,0 +1,150 @@
+import { z } from 'zod';
+import { basename } from 'path';
+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 uploadSubcommand = createSubcommand({
+	name: 'upload',
+	aliases: ['put'],
+	description: 'Upload a file to storage bucket',
+	tags: ['write', 'requires-auth'],
+	requires: { auth: true, org: true, region: true },
+	idempotent: false,
+	examples: [
+		`${getCommand('cloud storage upload')} my-bucket file.txt`,
+		`${getCommand('cloud storage put')} my-bucket file.txt --content-type text/plain`,
+		`cat file.txt | ${getCommand('cloud storage upload')} my-bucket -`,
+	],
+	schema: {
+		args: z.object({
+			name: z.string().describe('Bucket name'),
+			filename: z.string().describe('File path to upload or "-" for STDIN'),
+		}),
+		options: z.object({
+			contentType: z
+				.string()
+				.optional()
+				.describe('Content type (auto-detected if not provided)'),
+		}),
+		response: z.object({
+			success: z.boolean().describe('Whether upload succeeded'),
+			bucket: z.string().describe('Bucket name'),
+			filename: z.string().describe('Uploaded filename'),
+			size: z.number().describe('File size in bytes'),
+		}),
+	},
+
+	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
+			);
+		}
+
+		// Read file content
+		let fileContent: Buffer;
+		let actualFilename: string;
+
+		if (args.filename === '-') {
+			// Read from STDIN
+			const chunks: Buffer[] = [];
+			for await (const chunk of Bun.stdin.stream()) {
+				chunks.push(Buffer.from(chunk));
+			}
+			fileContent = Buffer.concat(chunks);
+			actualFilename = 'stdin';
+		} else {
+			// Read from file
+			const file = Bun.file(args.filename);
+			if (!(await file.exists())) {
+				tui.fatal(`File not found: ${args.filename}`, ErrorCode.FILE_NOT_FOUND);
+			}
+			fileContent = Buffer.from(await file.arrayBuffer());
+			actualFilename = basename(args.filename);
+		}
+
+		// Auto-detect content type
+		let contentType = opts.contentType;
+		if (!contentType && args.filename !== '-') {
+			const filename = basename(args.filename);
+			const dotIndex = filename.lastIndexOf('.');
+			const ext = dotIndex > 0 ? filename.substring(dotIndex + 1).toLowerCase() : undefined;
+			const mimeTypes: Record<string, string> = {
+				txt: 'text/plain',
+				html: 'text/html',
+				css: 'text/css',
+				yaml: 'application/x-yaml',
+				yml: 'application/x-yaml',
+				js: 'application/javascript',
+				json: 'application/json',
+				xml: 'application/xml',
+				pdf: 'application/pdf',
+				zip: 'application/zip',
+				jpg: 'image/jpeg',
+				jpeg: 'image/jpeg',
+				png: 'image/png',
+				gif: 'image/gif',
+				svg: 'image/svg+xml',
+				mp4: 'video/mp4',
+				mp3: 'audio/mpeg',
+			};
+			contentType = ext ? mimeTypes[ext] : 'application/octet-stream';
+		}
+
+		// Upload using Bun.s3
+		const s3Client = createS3Client({
+			endpoint: bucket.endpoint,
+			access_key: bucket.access_key,
+			secret_key: bucket.secret_key,
+			region: bucket.region,
+		});
+
+		await tui.spinner({
+			message: `Uploading ${actualFilename} to ${args.name}`,
+			clearOnSuccess: true,
+			callback: async () => {
+				await s3Client.write(actualFilename, fileContent, {
+					type: contentType,
+				});
+			},
+		});
+
+		if (!options.json) {
+			tui.success(
+				`Uploaded ${tui.bold(actualFilename)} to ${tui.bold(args.name)} (${fileContent.length} bytes)`
+			);
+		}
+
+		return {
+			success: true,
+			bucket: args.name,
+			filename: actualFilename,
+			size: fileContent.length,
+		};
+	},
+});

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

@@ -0,0 +1,26 @@
+import { S3Client } from 'bun';
+
+/**
+ * Creates an S3Client configured for Agentuity storage buckets
+ *
+ * Agentuity provides bucket-specific endpoints in virtual-hosted-style format.
+ * The endpoint is already bucket-specific (e.g., bucket-name.agentuity.run),
+ * so we use virtualHostedStyle: true WITHOUT passing a bucket parameter.
+ *
+ * @param bucket - Bucket configuration with endpoint, credentials, and region
+ * @returns Configured S3Client instance
+ */
+export function createS3Client(bucket: {
+	endpoint: string;
+	access_key: string;
+	secret_key: string;
+	region?: string | null;
+}): S3Client {
+	return new S3Client({
+		endpoint: bucket.endpoint.startsWith('http') ? bucket.endpoint : `https://${bucket.endpoint}`,
+		accessKeyId: bucket.access_key,
+		secretAccessKey: bucket.secret_key,
+		region: bucket.region || 'auto',
+		virtualHostedStyle: true,
+	});
+}

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

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createStorageAdapter } from './util';
+import { getCommand } from '../../../command-prefix';
+
+const DeleteStreamResponseSchema = z.object({
+	id: z.string().describe('Stream ID'),
+});
+
+export const deleteSubcommand = createCommand({
+	name: 'delete',
+	aliases: ['del', 'rm'],
+	description: 'Delete a stream by ID (soft delete)',
+	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth'],
+	idempotent: true,
+	requires: { auth: true, project: true },
+	examples: [
+		`${getCommand('stream delete stream-id-123')} - Delete a stream`,
+		`${getCommand('stream rm stream-id-456')} - Delete stream (using alias)`,
+		`${getCommand('stream del stream-id-789')} - Delete stream (using alias)`,
+	],
+	schema: {
+		args: z.object({
+			id: z.string().min(1).describe('the stream ID to delete'),
+		}),
+		response: DeleteStreamResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const started = Date.now();
+		const storage = await createStorageAdapter(ctx);
+
+		await storage.delete(args.id);
+
+		const durationMs = Date.now() - started;
+
+		if (!options.json) {
+			tui.success(`deleted stream ${args.id} in ${durationMs.toFixed(1)}ms`);
+		}
+
+		return {
+			id: args.id,
+		};
+	},
+});
+
+export default deleteSubcommand;