@agentuity/cli 1.0.22 → 1.0.24

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

@@ -5,6 +5,7 @@ import { deleteSubcommand } from './delete';
 import { getSubcommand } from './get';
 import { logsSubcommand } from './logs';
 import { sqlSubcommand } from './sql';
+import { statsSubcommand } from './stats';
 import { getCommand } from '../../../command-prefix';
 
 export const dbCommand = createCommand({
@@ -23,5 +24,6 @@ export const dbCommand = createCommand({
 		deleteSubcommand,
 		logsSubcommand,
 		sqlSubcommand,
+		statsSubcommand,
 	],
 });

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

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getGlobalCatalystAPIClient } from '../../../config';
+import { getCommand } from '../../../command-prefix';
+import { getServiceStats, type ServiceStatsData } from '@agentuity/server';
+
+function formatNumber(n: number): string {
+	if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+	if (n >= 1_000) return `${(n / 1_000).toFixed(1)}K`;
+	return String(n);
+}
+
+function displayStats(data: ServiceStatsData): void {
+	const svc = data.services.database;
+	if (!svc) {
+		tui.info('No database data found.');
+		return;
+	}
+	tui.header('Database Statistics');
+	tui.newline();
+	console.log(
+		`  ${tui.muted('Databases:')}       ${formatNumber(svc.databaseCount)}`
+	);
+	console.log(
+		`  ${tui.muted('Tables:')}          ${formatNumber(svc.totalTableCount)}`
+	);
+	console.log(
+		`  ${tui.muted('Records:')}         ${formatNumber(svc.totalRecordCount)}`
+	);
+	console.log(
+		`  ${tui.muted('Total Size:')}      ${tui.formatBytes(svc.totalSizeBytes)}`
+	);
+}
+
+export const statsSubcommand = createCommand({
+	name: 'stats',
+	description: 'View database statistics',
+	tags: ['read-only', 'requires-auth'],
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('cloud db stats'),
+			description: 'View database statistics',
+		},
+	],
+	schema: {
+		options: z.object({
+			start: z.string().optional().describe('Start time (ISO 8601)'),
+			end: z.string().optional().describe('End time (ISO 8601)'),
+		}),
+	},
+	idempotent: true,
+
+	async handler(ctx) {
+		const { opts, options } = ctx;
+		const client = await getGlobalCatalystAPIClient(ctx.logger, ctx.auth, ctx.config?.name);
+		const orgId = ctx.orgId ?? ctx.options.orgId ?? ctx.config?.preferences?.orgId;
+
+		if (!orgId) {
+			ctx.logger.fatal('Organization ID is required. Use --org-id or set a preferred org.');
+			return;
+		}
+
+		const data = await getServiceStats(client, orgId, {
+			service: 'database',
+			start: opts.start,
+			end: opts.end,
+			orgIdHeader: orgId,
+		});
+
+		if (!options.json) {
+			displayStats(data);
+		}
+
+		return data;
+	},
+});
+
+export default statsSubcommand;

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

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+import enquirer from 'enquirer';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { setResourceInfo } from '../../../cache';
+import { createEmailAdapter, resolveEmailOrgId, EmailAddressSchema } from './util';
+import { defaultProfileName, getDefaultRegion } from '../../../config';
+
+export const createSubcommand = createCommand({
+	name: 'create',
+	aliases: ['add'],
+	description: 'Create an email address',
+	tags: ['mutating', 'creates-resource', 'requires-auth'],
+	requires: { auth: true },
+	schema: {
+		options: z.object({
+			localPart: z
+				.string()
+				.optional()
+				.describe('Local part for the email address (before @)'),
+		}),
+		response: EmailAddressSchema,
+	},
+
+	async handler(ctx) {
+		const { opts, options, config } = ctx;
+		let localPart = opts.localPart?.trim();
+
+		if (!localPart) {
+			const answer = await enquirer.prompt<{ local_part: string }>({
+				type: 'input',
+				name: 'local_part',
+				message: 'Email address or username (e.g. "support" or "support@agentuity.email"):',
+			});
+			localPart = answer.local_part?.trim();
+		}
+
+		if (!localPart) {
+			tui.fatal('Email address or username is required');
+		}
+
+		// If user entered a full email, extract just the local part
+		if (localPart.includes('@')) {
+			localPart = localPart.split('@')[0]?.trim() ?? '';
+		}
+
+		if (!localPart) {
+			tui.fatal('Email address or username is required');
+		}
+
+		const profileName = config?.name ?? defaultProfileName;
+		const region = await getDefaultRegion(profileName, ctx.config);
+		const email = await createEmailAdapter(ctx, region);
+		const address = await email.createAddress(localPart);
+
+		const orgId = resolveEmailOrgId(ctx);
+		await setResourceInfo('email', profileName, address.id, region, orgId);
+
+		if (!options.json) {
+			tui.success(`Email Address: ${tui.bold(address.email)}`);
+			tui.table(
+				[
+					{
+						ID: address.id,
+						Email: address.email,
+						Project: address.project_id ?? '-',
+						Provider: address.provider ?? '-',
+						Created: new Date(address.created_at).toLocaleString(),
+					},
+				],
+				['ID', 'Email', 'Project', 'Provider', 'Created'],
+				{ layout: 'vertical', padStart: '  ' }
+			);
+		}
+
+		return address;
+	},
+});
+
+export default createSubcommand;

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

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createEmailAdapter } from './util';
+
+const DeleteResponseSchema = z.object({
+	success: z.boolean(),
+	id: z.string(),
+});
+
+export const deleteSubcommand = createCommand({
+	name: 'delete',
+	aliases: ['rm', 'del'],
+	description: 'Delete an email address',
+	tags: ['destructive', 'deletes-resource', 'requires-auth'],
+	requires: { auth: true },
+	schema: {
+		args: z.object({
+			id: z.string().min(1).describe('Email address ID (eaddr_*)'),
+		}),
+		options: z.object({
+			confirm: z.boolean().optional().default(false).describe('Skip confirmation prompt'),
+		}),
+		response: DeleteResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		if (!opts.confirm) {
+			const ok = await tui.confirm(`Delete email address ${tui.bold(args.id)}?`, false);
+			if (!ok) {
+				if (!options.json) {
+					tui.info('Cancelled');
+				}
+				return { success: false, id: args.id };
+			}
+		}
+
+		const email = await createEmailAdapter(ctx);
+		await email.deleteAddress(args.id);
+
+		if (!options.json) {
+			tui.success(`Deleted email address ${args.id}`);
+		}
+
+		return {
+			success: true,
+			id: args.id,
+		};
+	},
+});
+
+export default deleteSubcommand;

package/src/cmd/cloud/email/destination/delete.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { createCommand } from '../../../../types';
+import * as tui from '../../../../tui';
+import { createEmailAdapter } from '../util';
+
+const DeleteDestinationResponseSchema = z.object({
+	success: z.boolean(),
+	address_id: z.string(),
+	destination_id: z.string(),
+});
+
+export const deleteSubcommand = createCommand({
+	name: 'delete',
+	aliases: ['rm', 'del'],
+	description: 'Delete a destination from an email address',
+	tags: ['destructive', 'deletes-resource', 'requires-auth'],
+	requires: { auth: true },
+	schema: {
+		args: z.object({
+			address_id: z.string().min(1).describe('Email address ID (eaddr_*)'),
+			destination_id: z.string().min(1).describe('Destination ID (edest_*)'),
+		}),
+		options: z.object({
+			confirm: z.boolean().optional().default(false).describe('Skip confirmation prompt'),
+		}),
+		response: DeleteDestinationResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+
+		if (!args.address_id.startsWith('eaddr_')) {
+			tui.fatal('Invalid email address ID — must start with eaddr_');
+		}
+		if (!args.destination_id.startsWith('edest_')) {
+			tui.fatal('Invalid destination ID — must start with edest_');
+		}
+
+		if (!opts.confirm && !options.json) {
+			const ok = await tui.confirm(
+				`Delete destination ${tui.bold(args.destination_id)} from address ${tui.bold(args.address_id)}?`,
+				false
+			);
+			if (!ok) {
+				tui.info('Cancelled');
+				return { success: false, address_id: args.address_id, destination_id: args.destination_id };
+			}
+		}
+
+		const email = await createEmailAdapter(ctx);
+		await email.deleteDestination(args.address_id, args.destination_id);
+
+		if (!options.json) {
+			tui.success(`Deleted destination ${args.destination_id}`);
+		}
+
+		return {
+			success: true,
+			address_id: args.address_id,
+			destination_id: args.destination_id,
+		};
+	},
+});
+
+export default deleteSubcommand;

package/src/cmd/cloud/email/destination/index.ts

@@ -0,0 +1,15 @@
+import { createCommand } from '../../../../types';
+import { urlSubcommand } from './url';
+import { listSubcommand } from './list';
+import { deleteSubcommand } from './delete';
+
+export const destinationCommand = createCommand({
+	name: 'destination',
+	aliases: ['destinations', 'dest'],
+	description: 'Manage email destinations for an address',
+	tags: ['requires-auth'],
+	requires: { auth: true },
+	subcommands: [urlSubcommand, listSubcommand, deleteSubcommand],
+});
+
+export default destinationCommand;

package/src/cmd/cloud/email/destination/list.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { createCommand } from '../../../../types';
+import * as tui from '../../../../tui';
+import { createEmailAdapter } from '../util';
+import { DestinationSchema } from './schemas';
+
+export const listSubcommand = createCommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List destinations for an email address',
+	tags: ['read-only', 'requires-auth'],
+	requires: { auth: true },
+	schema: {
+		args: z.object({
+			address_id: z.string().min(1).describe('Email address ID (eaddr_*)'),
+		}),
+		response: z.array(DestinationSchema),
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const email = await createEmailAdapter(ctx);
+		const destinations = await email.listDestinations(args.address_id);
+
+		if (!options.json) {
+			tui.table(
+				destinations.map((item) => ({
+					ID: item.id,
+					Type: item.type,
+					'Config URL': typeof item.config?.url === 'string' ? item.config.url : '-',
+					Created: new Date(item.created_at).toLocaleString(),
+				})),
+				[
+					{ name: 'ID', alignment: 'left' },
+					{ name: 'Type', alignment: 'left' },
+					{ name: 'Config URL', alignment: 'left' },
+					{ name: 'Created', alignment: 'left' },
+				]
+			);
+		}
+
+		return destinations;
+	},
+});
+
+export default listSubcommand;

package/src/cmd/cloud/email/destination/schemas.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+
+export const DestinationSchema = z.object({
+	id: z.string(),
+	type: z.string(),
+	config: z.record(z.string(), z.unknown()).optional(),
+	created_at: z.string(),
+	updated_at: z.string().optional(),
+});

package/src/cmd/cloud/email/destination/url.ts

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+import { createCommand } from '../../../../types';
+import * as tui from '../../../../tui';
+import { setResourceInfo } from '../../../../cache';
+import { createEmailAdapter, resolveEmailOrgId } from '../util';
+import { defaultProfileName, getDefaultRegion } from '../../../../config';
+import { DestinationSchema } from './schemas';
+
+export const urlSubcommand = createCommand({
+	name: 'url',
+	description: 'Add a URL destination to an email address',
+	tags: ['mutating', 'creates-resource', 'requires-auth'],
+	requires: { auth: true },
+	schema: {
+		args: z.object({
+			address_id: z.string().min(1).describe('Email address ID (eaddr_*)'),
+			url: z
+				.string()
+				.url()
+				.refine((u) => /^https?:\/\//i.test(u), {
+					message: 'URL must use http or https protocol',
+				})
+				.describe('Destination webhook URL'),
+		}),
+		options: z.object({
+			method: z
+				.enum(['POST', 'PUT', 'PATCH'])
+				.optional()
+				.default('POST')
+				.describe('HTTP method (default: POST)'),
+		}),
+		response: DestinationSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options, config } = ctx;
+
+		const destinationConfig: Record<string, unknown> = {
+			url: args.url,
+		};
+		if (opts.method && opts.method !== 'POST') {
+			destinationConfig.method = opts.method;
+		}
+
+		const profileName = config?.name ?? defaultProfileName;
+		const region = await getDefaultRegion(profileName, ctx.config);
+		const email = await createEmailAdapter(ctx, region);
+		const destination = await email.createDestination(args.address_id, 'url', destinationConfig);
+
+		const orgId = resolveEmailOrgId(ctx);
+		setResourceInfo('email', profileName, destination.id, region, orgId).catch(() => {
+			// Non-blocking: destination was already created successfully
+		});
+
+		if (!options.json) {
+			tui.success(`Destination created: ${tui.bold(destination.id)}`);
+			tui.table(
+				[
+					{
+						ID: destination.id,
+						Type: 'url',
+						URL: args.url,
+						Method: opts.method ?? 'POST',
+						Created: new Date(destination.created_at).toLocaleString(),
+					},
+				],
+				['ID', 'Type', 'URL', 'Method', 'Created'],
+				{ layout: 'vertical', padStart: '  ' }
+			);
+		}
+
+		return destination;
+	},
+});
+
+export default urlSubcommand;

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

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createEmailAdapter, EmailAddressSchema } from './util';
+
+export const getSubcommand = createCommand({
+	name: 'get',
+	description: 'Get an email address by ID',
+	tags: ['read-only', 'requires-auth'],
+	requires: { auth: true },
+	schema: {
+		args: z.object({
+			id: z.string().min(1).describe('Email address ID (eaddr_*)'),
+		}),
+		response: EmailAddressSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const email = await createEmailAdapter(ctx);
+		const address = await email.getAddress(args.id);
+
+		if (!address) {
+			tui.fatal(`Email address not found: ${args.id}`);
+		}
+
+		if (!options.json) {
+			tui.success(`Email Address: ${tui.bold(address.email)}`);
+			tui.table(
+				[
+					{
+						ID: address.id,
+						Email: address.email,
+						Project: address.project_id ?? '-',
+						Provider: address.provider ?? '-',
+						Config: address.config ? JSON.stringify(address.config) : '-',
+						Created: new Date(address.created_at).toLocaleString(),
+						Updated: address.updated_at
+							? new Date(address.updated_at).toLocaleString()
+							: '-',
+					},
+				],
+				['ID', 'Email', 'Project', 'Provider', 'Config', 'Created', 'Updated'],
+				{ layout: 'vertical', padStart: '  ' }
+			);
+		}
+
+		return address;
+	},
+});
+
+export default getSubcommand;

package/src/cmd/cloud/email/inbound/get.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { createCommand } from '../../../../types';
+import * as tui from '../../../../tui';
+import { createEmailAdapter, truncate } from '../util';
+import { EmailInboundSchema } from './schemas';
+
+export const getSubcommand = createCommand({
+	name: 'get',
+	description: 'Get a received email by ID',
+	tags: ['read-only', 'requires-auth'],
+	requires: { auth: true },
+	schema: {
+		args: z.object({
+			id: z.string().min(1).describe('Inbound email ID (ein_*)'),
+		}),
+		response: EmailInboundSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const email = await createEmailAdapter(ctx);
+		const inbound = await email.getInbound(args.id);
+
+		if (!inbound) {
+			tui.fatal(`Inbound email not found: ${args.id}`);
+		}
+
+		if (!options.json) {
+			tui.success(`Inbound Email: ${tui.bold(inbound.id)}`);
+			tui.table(
+				[
+					{
+						ID: inbound.id,
+						From: inbound.from,
+						To: inbound.to,
+						Subject: inbound.subject ?? '-',
+						Text: truncate(inbound.text),
+						Received: inbound.received_at
+							? new Date(inbound.received_at).toLocaleString()
+							: '-',
+					},
+				],
+				['ID', 'From', 'To', 'Subject', 'Text', 'Received'],
+				{ layout: 'vertical', padStart: '  ' }
+			);
+		}
+
+		return inbound;
+	},
+});
+
+export default getSubcommand;

package/src/cmd/cloud/email/inbound/index.ts

@@ -0,0 +1,13 @@
+import { createCommand } from '../../../../types';
+import { listSubcommand } from './list';
+import { getSubcommand } from './get';
+
+export const inboundCommand = createCommand({
+	name: 'inbound',
+	description: 'Manage inbound (received) emails',
+	tags: ['requires-auth'],
+	requires: { auth: true },
+	subcommands: [listSubcommand, getSubcommand],
+});
+
+export default inboundCommand;

package/src/cmd/cloud/email/inbound/list.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import { createCommand } from '../../../../types';
+import * as tui from '../../../../tui';
+import { createEmailAdapter } from '../util';
+import { EmailInboundSchema } from './schemas';
+
+export const listSubcommand = createCommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List received emails',
+	tags: ['read-only', 'requires-auth'],
+	requires: { auth: true },
+	schema: {
+		options: z.object({
+			addressId: z.string().optional().describe('Filter by email address ID'),
+		}),
+		response: z.array(EmailInboundSchema),
+	},
+
+	async handler(ctx) {
+		const { opts, options } = ctx;
+		const email = await createEmailAdapter(ctx);
+		const inbound = await email.listInbound(opts.addressId);
+
+		if (!options.json) {
+			tui.table(
+				inbound.map((item) => ({
+					ID: item.id,
+					From: item.from,
+					To: item.to,
+					Subject: item.subject ?? '-',
+					Received: item.received_at ? new Date(item.received_at).toLocaleString() : '-',
+				})),
+				[
+					{ name: 'ID', alignment: 'left' },
+					{ name: 'From', alignment: 'left' },
+					{ name: 'To', alignment: 'left' },
+					{ name: 'Subject', alignment: 'left' },
+					{ name: 'Received', alignment: 'left' },
+				]
+			);
+		}
+
+		return inbound;
+	},
+});
+
+export default listSubcommand;

package/src/cmd/cloud/email/inbound/schemas.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+export const EmailInboundSchema = z.object({
+	id: z.string(),
+	from: z.string(),
+	to: z.string(),
+	subject: z.string().optional(),
+	text: z.string().optional(),
+	html: z.string().optional(),
+	received_at: z.string().optional(),
+	headers: z.record(z.string(), z.unknown()).optional(),
+	attachments: z.array(z.unknown()).optional(),
+});

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

@@ -0,0 +1,31 @@
+import { createCommand } from '../../../types';
+import { createSubcommand } from './create';
+import { listSubcommand } from './list';
+import { getSubcommand } from './get';
+import { deleteSubcommand } from './delete';
+import { destinationCommand } from './destination';
+import { sendSubcommand } from './send';
+import { inboundCommand } from './inbound';
+import { outboundCommand } from './outbound';
+import { statsSubcommand } from './stats';
+
+export const emailCommand = createCommand({
+	name: 'email',
+	aliases: ['mail'],
+	description: 'Manage email addresses and messages',
+	tags: ['requires-auth'],
+	subcommands: [
+		createSubcommand,
+		listSubcommand,
+		getSubcommand,
+		deleteSubcommand,
+		destinationCommand,
+		sendSubcommand,
+		inboundCommand,
+		outboundCommand,
+		statsSubcommand,
+	],
+	requires: { auth: true },
+});
+
+export default emailCommand;