@agentuity/cli 0.0.58 → 0.0.60

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

@@ -0,0 +1,114 @@
+import { z } from 'zod';
+import { createSubcommand as createSubcommandHelper } from '../../../types';
+import * as tui from '../../../tui';
+import { apikeyCreate } from '@agentuity/server';
+import { getCommand } from '../../../command-prefix';
+import { parseExpiresAt } from '../../../utils/date';
+
+const APIKeyCreateResponseSchema = z.object({
+	id: z.string().describe('the API key id'),
+	value: z.string().describe('the API key value'),
+});
+
+export const createSubcommand = createSubcommandHelper({
+	name: 'create',
+	aliases: ['new'],
+	description: 'Create a new API key',
+	tags: ['destructive', 'creates-resource', 'slow', 'requires-auth'],
+	examples: [
+		getCommand('cloud apikey create --name "My API Key" --expires-at 1y'),
+		getCommand('cloud apikey create --name "Short-lived Key" --expires-at 30d'),
+		getCommand(
+			'cloud apikey create --name "Production Key" --expires-at 2026-01-01T00:00:00Z --confirm'
+		),
+	],
+	requires: { auth: true, apiClient: true, org: true },
+	optional: { project: true },
+	idempotent: false,
+	schema: {
+		options: z.object({
+			name: z.string().describe('the name for the API key'),
+			'expires-at': z
+				.string()
+				.describe(
+					'expiration date as ISO 8601 (2025-12-31T23:59:59Z) or duration (1h, 2d, 30d, 1y)'
+				),
+			confirm: z
+				.boolean()
+				.optional()
+				.describe('Skip confirmation prompts (required for non-TTY)'),
+		}),
+		response: APIKeyCreateResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { opts, apiClient, project, orgId, options } = ctx;
+
+		const skipConfirm = opts?.confirm === true;
+
+		const projectId = project?.projectId ?? null;
+
+		// Parse expires-at (duration or ISO date)
+		let expiresAt: string;
+		try {
+			expiresAt = parseExpiresAt(opts['expires-at']);
+		} catch (error) {
+			if (error instanceof Error) {
+				tui.fatal(error.message);
+			}
+			throw error;
+		}
+
+		// Require --confirm flag when not in a TTY
+		if (!process.stdout.isTTY && !skipConfirm) {
+			tui.fatal('--confirm is required in non-interactive mode');
+		}
+
+		// Confirm creation in interactive mode
+		if (!skipConfirm) {
+			const scope = projectId ? `project ${projectId}` : `organization ${orgId}`;
+			const confirmed = await tui.confirm(`Create API key "${opts.name}" for ${scope}?`);
+			if (!confirmed) {
+				tui.fatal('Operation cancelled');
+			}
+		}
+
+		let result: Awaited<ReturnType<typeof apikeyCreate>>;
+		try {
+			result = await tui.spinner('Creating API key', () => {
+				return apikeyCreate(apiClient, {
+					name: opts.name,
+					expiresAt: expiresAt,
+					projectId: projectId,
+					orgId: orgId,
+				});
+			});
+		} catch (error) {
+			if (error instanceof Error) {
+				tui.fatal(error.message);
+			}
+			throw error;
+		}
+
+		if (!options.json) {
+			tui.newline();
+			tui.success('API key created successfully!');
+			tui.newline();
+			tui.warn('Make sure to copy the API key value now. You will not be able to see it again.');
+			tui.newline();
+
+			const rows = [
+				{
+					ID: result.id,
+					Name: opts.name,
+					Value: result.value,
+					'Expires At': expiresAt,
+				},
+			];
+
+			tui.table(rows);
+		}
+
+		return result;
+	},
+});

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

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { apikeyDelete } from '@agentuity/server';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+
+const APIKeyDeleteResponseSchema = z.object({
+	success: z.boolean().describe('Whether the operation succeeded'),
+	id: z.string().describe('API key id that was deleted'),
+});
+
+export const deleteSubcommand = createSubcommand({
+	name: 'delete',
+	aliases: ['del', 'rm'],
+	description: 'Delete an API key (soft delete)',
+	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth'],
+	idempotent: true,
+	examples: [
+		getCommand('cloud apikey delete <id>'),
+		getCommand('cloud apikey del <id>'),
+		getCommand('cloud apikey rm <id>'),
+	],
+	requires: { auth: true, apiClient: true },
+	schema: {
+		args: z.object({
+			id: z.string().describe('the API key id to delete'),
+		}),
+		response: APIKeyDeleteResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, apiClient, options } = ctx;
+
+		let rowsAffected: Awaited<ReturnType<typeof apikeyDelete>>;
+		try {
+			rowsAffected = await tui.spinner('Deleting API key', () => {
+				return apikeyDelete(apiClient, args.id);
+			});
+		} catch (error) {
+			if (error instanceof Error && error.message.includes('not found')) {
+				tui.fatal(
+					`API key '${args.id}' not found or is not a custom key`,
+					ErrorCode.RESOURCE_NOT_FOUND
+				);
+			}
+			throw error;
+		}
+
+		if (rowsAffected === 0) {
+			tui.fatal(
+				`API key '${args.id}' not found or is not a custom key`,
+				ErrorCode.RESOURCE_NOT_FOUND
+			);
+		}
+
+		if (!options.json) {
+			tui.success(`API key '${args.id}' deleted successfully`);
+		}
+
+		return {
+			success: true,
+			id: args.id,
+		};
+	},
+});

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

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { apikeyGet } from '@agentuity/server';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+
+export const getSubcommand = createSubcommand({
+	name: 'get',
+	description: 'Get a specific API key by id',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	examples: [getCommand('cloud apikey get <id>')],
+	requires: { auth: true, apiClient: true },
+	idempotent: true,
+	schema: {
+		args: z.object({
+			id: z.string().describe('the API key id'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { args, apiClient, options } = ctx;
+
+		let apiKey: Awaited<ReturnType<typeof apikeyGet>>;
+		try {
+			apiKey = await tui.spinner('Fetching API key', () => {
+				return apikeyGet(apiClient, args.id);
+			});
+		} catch (error) {
+			if (error instanceof Error && error.message.includes('not found')) {
+				tui.fatal(`API key '${args.id}' not found`, ErrorCode.RESOURCE_NOT_FOUND);
+			}
+			throw error;
+		}
+
+		if (!options.json) {
+			if (process.stdout.isTTY) {
+				tui.newline();
+				tui.success('API Key Details:');
+				tui.newline();
+			}
+
+			const rows = [
+				{
+					ID: apiKey.id,
+					Name: apiKey.name,
+					Type: apiKey.type,
+					'Organization ID': apiKey.orgId,
+					Project: apiKey.project?.name ?? '-',
+					'Project ID': apiKey.project?.id ?? '-',
+					'Last Used': apiKey.lastUsedAt || 'Never',
+					'Expires At': apiKey.expiresAt ?? 'Never',
+					'Created At': apiKey.createdAt,
+				},
+			];
+
+			tui.table(rows);
+		}
+
+		return apiKey;
+	},
+});

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

@@ -0,0 +1,13 @@
+import { createCommand } from '../../../types';
+import { createSubcommand } from './create';
+import { listSubcommand } from './list';
+import { getSubcommand } from './get';
+import { deleteSubcommand } from './delete';
+
+export const command = createCommand({
+	name: 'apikey',
+	description: 'Manage API keys',
+	tags: ['fast', 'requires-auth'],
+	subcommands: [createSubcommand, listSubcommand, getSubcommand, deleteSubcommand],
+});
+export default command;

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

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { apikeyList } from '@agentuity/server';
+import { getCommand } from '../../../command-prefix';
+
+export const listSubcommand = createSubcommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List all API keys',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	examples: [getCommand('cloud apikey list'), getCommand('cloud apikey ls')],
+	requires: { auth: true, apiClient: true },
+	idempotent: true,
+	schema: {
+		options: z.object({
+			orgId: z.string().optional().describe('filter by organization id'),
+			projectId: z.string().optional().describe('filter by project id'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { opts, apiClient, options } = ctx;
+
+		const apiKeys = await tui.spinner('Fetching API keys', () => {
+			return apikeyList(apiClient, {
+				orgId: opts?.orgId,
+				projectId: opts?.projectId,
+			});
+		});
+
+		if (!options.json) {
+			if (apiKeys.length === 0) {
+				tui.info('No API keys found');
+			} else {
+				if (process.stdout.isTTY) {
+					tui.newline();
+					tui.success(`API Keys (${apiKeys.length}):`);
+					tui.newline();
+				}
+
+				const rows = apiKeys.map((key) => ({
+					ID: key.id,
+					Name: key.name,
+					Type: key.type,
+					Project: key.project?.name ?? '-',
+					'Last Used': key.lastUsedAt || 'Never',
+					'Expires At': key.expiresAt ?? 'Never',
+					'Created At': key.createdAt,
+				}));
+
+				tui.table(rows);
+			}
+		}
+
+		return apiKeys;
+	},
+});

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

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

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,
+			})),
+		};
+	},
+});