@agentuity/cli 0.0.58 → 0.0.60

package/src/cmd/cloud/db/sql.ts

@@ -0,0 +1,125 @@
+import { z } from 'zod';
+import { SQL } from 'bun';
+import { listResources, type ResourceList } 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';
+
+interface DatabaseResource {
+	name: string;
+	username?: string | null;
+	password?: string | null;
+	url?: string | null;
+}
+
+const DBSQLResponseSchema = z.object({
+	rows: z.array(z.record(z.string(), z.unknown())).describe('Query results'),
+	rowCount: z.number().describe('Number of rows returned'),
+	executionTime: z.number().optional().describe('Query execution time in ms'),
+});
+
+export const sqlSubcommand = createSubcommand({
+	name: 'sql',
+	aliases: ['exec', 'query'],
+	description: 'Execute SQL query on a database',
+	tags: ['slow', 'requires-auth'],
+	requires: { auth: true, org: true, region: true },
+	idempotent: false,
+	examples: [
+		`${getCommand('cloud db sql')} my-database "SELECT * FROM users LIMIT 10"`,
+		`${getCommand('cloud db exec')} my-database "SELECT COUNT(*) FROM orders" --json`,
+		`${getCommand('cloud db query')} my-database "SELECT * FROM products WHERE price > 100"`,
+	],
+	schema: {
+		args: z.object({
+			name: z.string().describe('Database name'),
+			query: z.string().describe('SQL query to execute'),
+		}),
+		options: z.object({}),
+		response: DBSQLResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { logger, args, options, orgId, region, config, auth } = ctx;
+
+		const catalystClient = getCatalystAPIClient(config, logger, auth);
+
+		const resources: ResourceList = await tui.spinner({
+			message: `Fetching database ${args.name}`,
+			clearOnSuccess: true,
+			callback: async () => {
+				return listResources(catalystClient, orgId, region);
+			},
+		});
+
+		const db: DatabaseResource | undefined = resources.db.find(
+			(d: DatabaseResource) => d.name === args.name
+		);
+
+		if (!db) {
+			tui.fatal(`Database '${args.name}' not found`, ErrorCode.RESOURCE_NOT_FOUND);
+		}
+
+		if (!db.url) {
+			tui.fatal(`Database '${args.name}' has no connection URL`, ErrorCode.RUNTIME_ERROR);
+		}
+
+		let database: SQL | undefined;
+		let rows: Record<string, unknown>[];
+		let executionTime: number | undefined;
+
+		try {
+			// Add sslmode=require if not already present in URL
+			let connectionUrl = db.url;
+			if (!connectionUrl.includes('sslmode=') && !connectionUrl.includes('ssl=')) {
+				const separator = connectionUrl.includes('?') ? '&' : '?';
+				connectionUrl = `${connectionUrl}${separator}sslmode=require`;
+			}
+
+			database = new SQL(connectionUrl);
+
+			const startTime = performance.now();
+			const result = await tui.spinner({
+				message: `Executing query on ${args.name}`,
+				clearOnSuccess: true,
+				callback: async () => {
+					return database!.unsafe(args.query);
+				},
+			});
+			executionTime = performance.now() - startTime;
+
+			rows = result;
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			tui.fatal(`Query execution failed: ${message}`, ErrorCode.RUNTIME_ERROR);
+		} finally {
+			if (database) {
+				await database.close();
+			}
+		}
+
+		if (!options.json) {
+			if (rows.length === 0) {
+				tui.info('No rows returned');
+			} else {
+				if (process.stdout.isTTY) {
+					tui.newline();
+					tui.success(
+						`Query returned ${rows.length} row${rows.length !== 1 ? 's' : ''} (${executionTime?.toFixed(2)}ms):`
+					);
+					tui.newline();
+				}
+
+				tui.table(rows);
+			}
+		}
+
+		return {
+			rows,
+			rowCount: rows.length,
+			executionTime,
+		};
+	},
+});

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

@@ -1,5 +1,6 @@
 import { createCommand } from '../../../types';
 import { listSubcommand } from './list';
+import { logsSubcommand } from './logs';
 import { showSubcommand } from './show';
 import { removeSubcommand } from './remove';
 import { rollbackSubcommand } from './rollback';
@@ -12,6 +13,7 @@ export const deploymentCommand = createCommand({
 	aliases: ['deployments', 'dep'],
 	subcommands: [
 		listSubcommand,
+		logsSubcommand,
 		showSubcommand,
 		removeSubcommand,
 		rollbackSubcommand,

package/src/cmd/cloud/deployment/logs.ts

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { projectDeploymentLogs, DeploymentLogSchema } from '@agentuity/server';
+import { resolveProjectId } from './utils';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+
+export const logsSubcommand = createSubcommand({
+	name: 'logs',
+	aliases: ['log'],
+	description: 'View logs for a specific deployment',
+	tags: ['read-only', 'fast', 'requires-auth', 'requires-deployment'],
+	examples: [
+		`${getCommand('cloud deployment logs')} deploy_abc123xyz`,
+		`${getCommand('cloud deployment logs')} deploy_abc123xyz --limit=50`,
+		`${getCommand('cloud deployment logs')} deploy_abc123xyz --no-timestamps  # hide timestamps`,
+		`${getCommand('cloud deployment logs')} deploy_abc123xyz --project-id=proj_abc123xyz`,
+	],
+	requires: { auth: true, apiClient: true },
+	optional: { project: true },
+	prerequisites: ['cloud deploy'],
+	schema: {
+		args: z.object({
+			deployment_id: z.string().describe('Deployment ID'),
+		}),
+		options: z.object({
+			projectId: z.string().optional().describe('Project ID'),
+			limit: z.coerce
+				.number()
+				.int()
+				.min(1)
+				.default(100)
+				.describe('Maximum number of logs to return'),
+			timestamps: z.boolean().default(true).describe('Show timestamps in output'),
+		}),
+		response: z.array(DeploymentLogSchema),
+	},
+	idempotent: true,
+	async handler(ctx) {
+		const { apiClient, args, options } = ctx;
+		const limit = ctx.opts.limit;
+		const showTimestamps = ctx.opts.timestamps;
+
+		try {
+			const projectId = resolveProjectId(ctx, { projectId: ctx.opts.projectId });
+			const logs = await projectDeploymentLogs(apiClient, projectId, args.deployment_id, limit);
+
+			if (!options.json) {
+				if (logs.length === 0) {
+					tui.info('No logs found for this deployment');
+				} else {
+					for (const log of logs) {
+						const severityColor = tui.getSeverityColor(log.severity);
+						if (showTimestamps) {
+							const timestamp = new Date(log.timestamp).toLocaleString();
+							console.log(
+								`${tui.muted(timestamp)} ${severityColor(log.severity.padEnd(5))} ${log.body}`
+							);
+						} else {
+							console.log(`${severityColor(log.severity.padEnd(5))} ${log.body}`);
+						}
+					}
+				}
+			}
+
+			return logs;
+		} catch (ex) {
+			tui.fatal(
+				`Failed to fetch deployment logs: ${ex instanceof Error ? ex.message : String(ex)}`,
+				ErrorCode.API_ERROR
+			);
+		}
+	},
+});

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

@@ -2,7 +2,6 @@ import { z } from 'zod';
 import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
 import { projectGet } from '@agentuity/server';
-import { maskSecret } from '../../../env-util';
 import { getCommand } from '../../../command-prefix';
 import { ErrorCode } from '../../../errors';
 
@@ -50,13 +49,13 @@ export const getSubcommand = createSubcommand({
 			// Display the value, masked if requested
 			if (process.stdout.isTTY) {
 				if (opts?.mask) {
-					tui.success(`${args.key}=${maskSecret(value)}`);
+					tui.success(`${args.key}=${tui.maskSecret(value)}`);
 				} else {
 					tui.success(`${args.key}=${value}`);
 				}
 			} else {
 				if (opts?.mask) {
-					console.log(`${args.key}=${maskSecret(value)}`);
+					console.log(`${args.key}=${tui.maskSecret(value)}`);
 				} else {
 					console.log(`${args.key}=${value}`);
 				}

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

@@ -2,7 +2,6 @@ import { z } from 'zod';
 import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
 import { projectGet } from '@agentuity/server';
-import { maskSecret } from '../../../env-util';
 import { getCommand } from '../../../command-prefix';
 
 const EnvListResponseSchema = z.record(
@@ -55,7 +54,7 @@ export const listSubcommand = createSubcommand({
 				const shouldMask = opts?.mask === true;
 				for (const key of sortedKeys) {
 					const value = env[key];
-					const displayValue = shouldMask ? maskSecret(value) : value;
+					const displayValue = shouldMask ? tui.maskSecret(value) : value;
 					if (process.stdout.isTTY) {
 						console.log(`${tui.bold(key)}=${displayValue}`);
 					} else {

package/src/cmd/cloud/index.ts

@@ -1,28 +1,37 @@
 import { createCommand } from '../../types';
 import { deploySubcommand } from './deploy';
-import { resourceSubcommand } from './resource';
+import { dbCommand } from './db';
+import { storageCommand } from './storage';
 import { sessionCommand } from './session';
 import { sshSubcommand } from './ssh';
 import { scpSubcommand } from './scp';
 import { deploymentCommand } from './deployment';
 import keyvalueCommand from './keyvalue';
-import agentsCommand from './agents';
+import { agentCommand } from './agent';
 import objectstoreCommand from './objectstore';
 import envCommand from './env';
 import secretCommand from './secret';
+import apikeyCommand from './apikey';
+import streamCommand from './stream';
+import vectorCommand from './vector';
+
 
 export const command = createCommand({
 	name: 'cloud',
 	description: 'Cloud related commands',
 	tags: ['slow', 'requires-auth'],
 	subcommands: [
+		apikeyCommand,
 		keyvalueCommand,
-		agentsCommand,
+		agentCommand,
 		objectstoreCommand,
+		streamCommand,
+		vectorCommand,
 		envCommand,
 		secretCommand,
 		deploySubcommand,
-		resourceSubcommand,
+		dbCommand,
+		storageCommand,
 		sessionCommand,
 		sshSubcommand,
 		scpSubcommand,

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

@@ -2,7 +2,6 @@ import { z } from 'zod';
 import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
 import { projectGet } from '@agentuity/server';
-import { maskSecret } from '../../../env-util';
 import { getCommand } from '../../../command-prefix';
 import { ErrorCode } from '../../../errors';
 
@@ -53,14 +52,14 @@ export const getSubcommand = createSubcommand({
 			if (process.stdout.isTTY) {
 				// Display the value, masked by default
 				if (opts?.mask) {
-					tui.success(`${args.key}=${maskSecret(value)}`);
+					tui.success(`${args.key}=${tui.maskSecret(value)}`);
 				} else {
 					tui.success(`${args.key}=${value}`);
 				}
 			} else {
 				// Display the value, masked by default
 				if (opts?.mask) {
-					console.log(`${args.key}=${maskSecret(value)}`);
+					console.log(`${args.key}=${tui.maskSecret(value)}`);
 				} else {
 					console.log(`${args.key}=${value}`);
 				}

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

@@ -2,7 +2,6 @@ import { z } from 'zod';
 import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
 import { projectGet } from '@agentuity/server';
-import { maskSecret } from '../../../env-util';
 import { getCommand } from '../../../command-prefix';
 
 const SecretListResponseSchema = z.record(z.string(), z.string().describe('Secret value'));
@@ -52,7 +51,7 @@ export const listSubcommand = createSubcommand({
 				const shouldMask = opts?.mask !== false;
 				for (const key of sortedKeys) {
 					const value = secrets[key];
-					const displayValue = shouldMask ? maskSecret(value) : value;
+					const displayValue = shouldMask ? tui.maskSecret(value) : value;
 					if (process.stdout.isTTY) {
 						console.log(`${tui.bold(key)}=${displayValue}`);
 					} else {

package/src/cmd/cloud/session/logs.ts

@@ -15,9 +15,13 @@ const SessionLogsResponseSchema = z.array(
 
 export const logsSubcommand = createSubcommand({
 	name: 'logs',
+	aliases: ['log'],
 	description: 'Get logs for a specific session',
 	tags: ['read-only', 'slow', 'requires-auth'],
-	examples: [`${getCommand('cloud session logs')} sess_abc123xyz`],
+	examples: [
+		`${getCommand('cloud session logs')} sess_abc123xyz`,
+		`${getCommand('cloud session logs')} --no-timestamps  # hide timestamps`,
+	],
 	requires: { auth: true, apiClient: true },
 	optional: { project: true },
 	idempotent: true,
@@ -28,11 +32,13 @@ export const logsSubcommand = createSubcommand({
 		options: z.object({
 			projectId: z.string().optional().describe('Project ID (for display purposes)'),
 			deploymentId: z.string().optional().describe('Deployment ID (for display purposes)'),
+			timestamps: z.boolean().default(true).describe('Show timestamps in output'),
 		}),
 		response: SessionLogsResponseSchema,
 	},
 	async handler(ctx) {
 		const { apiClient, args, options } = ctx;
+		const showTimestamps = ctx.opts.timestamps ?? true;
 
 		try {
 			const logs = await sessionLogs(apiClient, { id: args.session_id });
@@ -41,19 +47,14 @@ export const logsSubcommand = createSubcommand({
 				if (logs.length === 0) {
 					tui.info('No logs found for this session.');
 				} else {
-					tui.banner(`Logs for Session ${args.session_id}`, `${logs.length} log entries`);
-
 					for (const log of logs) {
-						const timestamp = new Date(log.timestamp).toLocaleTimeString();
+						const timestamp = showTimestamps
+							? `${tui.muted(new Date(log.timestamp).toLocaleTimeString())} `
+							: '';
 						const severity = log.severity.padEnd(5);
-						const severityColor =
-							log.severity === 'ERROR'
-								? tui.error(severity)
-								: log.severity === 'WARN'
-									? tui.warning(severity)
-									: tui.muted(severity);
+						const severityColor = tui.getSeverityColor(log.severity)(severity);
 
-						console.log(`${tui.muted(timestamp)} ${severityColor} ${log.body}`);
+						console.log(`${timestamp}${severityColor} ${log.body}`);
 					}
 				}
 			}

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

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { createResources } 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';
+
+export const createSubcommand = defineSubcommand({
+	name: 'create',
+	aliases: ['new'],
+	description: 'Create a new storage resource',
+	tags: ['mutating', 'creates-resource', 'slow', 'requires-auth', 'requires-deployment'],
+	idempotent: false,
+	requires: { auth: true, org: true, region: true },
+	examples: [
+		getCommand('cloud storage create'),
+		getCommand('cloud storage new'),
+		getCommand('--dry-run cloud storage create'),
+	],
+	schema: {
+		response: z.object({
+			success: z.boolean().describe('Whether creation succeeded'),
+			name: z.string().describe('Created storage bucket name'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { logger, orgId, region, config, auth, options } = ctx;
+
+		// Handle dry-run mode
+		if (isDryRunMode(options)) {
+			const message = `Would create storage bucket in region: ${region}`;
+			outputDryRun(message, options);
+			if (!options.json) {
+				tui.newline();
+				tui.info('[DRY RUN] Storage creation skipped');
+			}
+			return {
+				success: false,
+				name: 'dry-run-bucket',
+			};
+		}
+
+		const catalystClient = getCatalystAPIClient(config, logger, auth);
+
+		const created = await tui.spinner({
+			message: `Creating storage in ${region}`,
+			clearOnSuccess: true,
+			callback: async () => {
+				return createResources(catalystClient, orgId, region!, [{ type: 's3' }]);
+			},
+		});
+
+		if (created.length > 0) {
+			tui.success(`Created storage: ${tui.bold(created[0].name)}`);
+			return {
+				success: true,
+				name: created[0].name,
+			};
+		} else {
+			tui.fatal('Failed to create storage');
+		}
+	},
+});

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

@@ -0,0 +1,195 @@
+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: [
+		getCommand('cloud storage delete my-bucket'),
+		getCommand('cloud storage rm my-bucket file.txt'),
+		getCommand('cloud storage delete'),
+		getCommand('--dry-run cloud storage delete my-bucket'),
+	],
+	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 };
+		}
+	},
+});