@agentuity/cli 0.0.59 → 0.0.60

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

@@ -0,0 +1,118 @@
+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';
+
+export const deleteSubcommand = createSubcommand({
+	name: 'delete',
+	aliases: ['rm', 'del'],
+	description: 'Delete a database resource',
+	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth', 'requires-deployment'],
+	idempotent: false,
+	requires: { auth: true, org: true, region: true },
+	examples: [
+		getCommand('cloud db delete my-database'),
+		getCommand('cloud db rm my-database'),
+		getCommand('cloud db delete'),
+		getCommand('--dry-run cloud db delete my-database'),
+	],
+	schema: {
+		args: z.object({
+			name: z.string().optional().describe('Database name to delete'),
+		}),
+		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 database name'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { logger, args, opts, config, orgId, region, auth, options } = ctx;
+
+		const catalystClient = getCatalystAPIClient(config, logger, auth);
+
+		let dbName = args.name;
+
+		if (!dbName) {
+			const resources = await tui.spinner({
+				message: `Fetching databases for ${orgId} in ${region}`,
+				clearOnSuccess: true,
+				callback: async () => {
+					return listResources(catalystClient, orgId, region!);
+				},
+			});
+
+			if (resources.db.length === 0) {
+				tui.info('No databases found to delete');
+				return { success: false, name: '' };
+			}
+
+			const response = await enquirer.prompt<{ db: string }>({
+				type: 'select',
+				name: 'db',
+				message: 'Select database to delete:',
+				choices: resources.db.map((db) => ({
+					name: db.name,
+					message: db.name,
+				})),
+			});
+
+			dbName = response.db;
+		}
+
+		// Handle dry-run mode
+		if (isDryRunMode(options)) {
+			outputDryRun(`Would delete database: ${dbName}`, options);
+			if (!options.json) {
+				tui.newline();
+				tui.info('[DRY RUN] Database deletion skipped');
+			}
+			return {
+				success: false,
+				name: dbName,
+			};
+		}
+
+		if (!opts.confirm) {
+			tui.warning(`You are about to delete database: ${tui.bold(dbName)}`);
+
+			const confirm = await enquirer.prompt<{ confirm: boolean }>({
+				type: 'confirm',
+				name: 'confirm',
+				message: 'Are you sure you want to delete this database?',
+				initial: false,
+			});
+
+			if (!confirm.confirm) {
+				tui.info('Deletion cancelled');
+				return { success: false, name: dbName };
+			}
+		}
+
+		const deleted = await tui.spinner({
+			message: `Deleting database ${dbName}`,
+			clearOnSuccess: true,
+			callback: async () => {
+				return deleteResources(catalystClient, orgId, region!, [{ type: 'db', name: dbName }]);
+			},
+		});
+
+		if (deleted.length > 0) {
+			tui.success(`Deleted database: ${tui.bold(deleted[0])}`);
+			return {
+				success: true,
+				name: deleted[0],
+			};
+		} else {
+			tui.error('Failed to delete database');
+			return { success: false, name: dbName };
+		}
+	},
+});

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

@@ -0,0 +1,75 @@
+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 DBGetResponseSchema = z.object({
+	name: z.string().describe('Database name'),
+	url: z.string().optional().describe('Database connection URL'),
+});
+
+export const getSubcommand = createSubcommand({
+	name: 'get',
+	aliases: ['show'],
+	description: 'Show details about a specific database',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true, org: true, region: true },
+	idempotent: true,
+	examples: [
+		`${getCommand('cloud db get')} my-database`,
+		`${getCommand('cloud db show')} my-database`,
+		`${getCommand('cloud db get')} my-database --show-credentials`,
+	],
+	schema: {
+		args: z.object({
+			name: z.string().describe('Database name'),
+		}),
+		options: z.object({
+			showCredentials: z
+				.boolean()
+				.optional()
+				.describe('Show credentials in plain text (default: masked in terminal, unmasked in JSON)'),
+		}),
+		response: DBGetResponseSchema,
+	},
+
+	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 database ${args.name}`,
+			clearOnSuccess: true,
+			callback: async () => {
+				return listResources(catalystClient, orgId, region);
+			},
+		});
+
+		const db = resources.db.find((d) => d.name === args.name);
+
+		if (!db) {
+			tui.fatal(`Database '${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('Name: ') + db.name);
+			if (db.url) {
+				const displayUrl = shouldMask ? tui.maskSecret(db.url) : db.url;
+				console.log(tui.bold('URL:  ') + displayUrl);
+			}
+		}
+
+		return {
+			name: db.name,
+			url: db.url ?? undefined,
+		};
+	},
+});

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

@@ -0,0 +1,14 @@
+import { createCommand } from '../../../types';
+import { createSubcommand } from './create';
+import { listSubcommand } from './list';
+import { deleteSubcommand } from './delete';
+import { getSubcommand } from './get';
+import { sqlSubcommand } from './sql';
+
+export const dbCommand = createCommand({
+	name: 'db',
+	aliases: ['database'],
+	description: 'Manage database resources',
+	tags: ['slow', 'requires-auth', 'requires-deployment'],
+	subcommands: [createSubcommand, listSubcommand, getSubcommand, deleteSubcommand, sqlSubcommand],
+});

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

@@ -0,0 +1,83 @@
+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';
+
+const DBListResponseSchema = z.object({
+	databases: z
+		.array(
+			z.object({
+				name: z.string().describe('Database name'),
+				url: z.string().optional().describe('Database connection URL'),
+			})
+		)
+		.describe('List of database resources'),
+});
+
+export const listSubcommand = createSubcommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List database resources',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true, org: true, region: true },
+	idempotent: true,
+	examples: [
+		getCommand('cloud db list'),
+		getCommand('--json cloud db list'),
+		getCommand('cloud db ls'),
+		getCommand('cloud db list --show-credentials'),
+	],
+	schema: {
+		options: z.object({
+			showCredentials: z
+				.boolean()
+				.optional()
+				.describe('Show credentials in plain text (default: masked in terminal, unmasked in JSON)'),
+		}),
+		response: DBListResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { logger, opts, options, orgId, region, config, auth } = ctx;
+
+		const catalystClient = getCatalystAPIClient(config, logger, auth);
+
+		const resources = await tui.spinner({
+			message: `Fetching databases for ${orgId} in ${region}`,
+			clearOnSuccess: true,
+			callback: async () => {
+				return listResources(catalystClient, orgId, region);
+			},
+		});
+
+		// 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.db.length === 0) {
+				tui.info('No databases found');
+			} else {
+				tui.info(tui.bold('Databases'));
+				tui.newline();
+				for (const db of resources.db) {
+					console.log(tui.bold(db.name));
+					if (db.url) {
+						const displayUrl = shouldMask ? tui.maskSecret(db.url) : db.url;
+						console.log(` URL: ${tui.muted(displayUrl)}`);
+					}
+					tui.newline();
+				}
+			}
+		}
+
+		return {
+			databases: resources.db.map((db) => ({
+				name: db.name,
+				url: db.url ?? undefined,
+			})),
+		};
+	},
+});

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/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,6 +1,7 @@
 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';
@@ -14,6 +15,7 @@ import apikeyCommand from './apikey';
 import streamCommand from './stream';
 import vectorCommand from './vector';
 
+
 export const command = createCommand({
 	name: 'cloud',
 	description: 'Cloud related commands',
@@ -28,7 +30,8 @@ export const command = createCommand({
 		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/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');
+		}
+	},
+});