@agentuity/cli 1.0.23 → 1.0.25

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

@@ -32,12 +32,14 @@ export const getSubcommand = createCommand({
 	name: 'get',
 	description: 'Get schedule details',
 	tags: ['read-only', 'fast', 'requires-auth'],
-	requires: { auth: true, region: true },
-	optional: { project: true },
+	requires: { auth: true },
 	idempotent: true,
-		examples: [
-			{ command: getCommand('cloud schedule get sched_abc123'), description: 'Get schedule details' },
-		],
+	examples: [
+		{
+			command: getCommand('cloud schedule get sched_abc123'),
+			description: 'Get schedule details',
+		},
+	],
 	schema: {
 		args: z.object({
 			schedule_id: z.string().min(1).describe('Schedule ID'),
@@ -47,7 +49,7 @@ export const getSubcommand = createCommand({
 
 	async handler(ctx) {
 		const { args, options } = ctx;
-		const schedule = createScheduleAdapter(ctx);
+		const schedule = await createScheduleAdapter(ctx);
 		const result = await schedule.get(args.schedule_id);
 
 		if (!options.json) {
@@ -55,7 +57,7 @@ export const getSubcommand = createCommand({
 				Name: result.schedule.name,
 				ID: result.schedule.id,
 				Expression: result.schedule.expression,
-				Description: result.schedule.description ?? '-',
+				Description: result.schedule.description || '-',
 				'Next Due': result.schedule.due_date,
 				Created: new Date(result.schedule.created_at).toLocaleString(),
 				Updated: new Date(result.schedule.updated_at).toLocaleString(),
@@ -64,23 +66,31 @@ export const getSubcommand = createCommand({
 			tui.table([details], undefined, { layout: 'vertical', padStart: '  ' });
 
 			tui.newline();
-			tui.info('Destinations');
+			tui.header('Destinations');
 			if (result.destinations.length === 0) {
 				tui.info('No destinations configured');
 			} else {
 				tui.table(
-					result.destinations.map((destination: {
-						id: string;
-						type: 'url' | 'sandbox';
-						config: Record<string, unknown>;
-						created_at: string;
-					}) => ({
-						ID: destination.id,
-						Type: destination.type,
-						Config: JSON.stringify(destination.config),
-						Created: new Date(destination.created_at).toLocaleString(),
-					})),
-					['ID', 'Type', 'Config', 'Created']
+					result.destinations.map(
+						(destination: {
+							id: string;
+							type: 'url' | 'sandbox';
+							config: Record<string, unknown>;
+							created_at: string;
+						}) => {
+							const configDisplay =
+								destination.type === 'url' && destination.config?.url
+									? String(destination.config.url)
+									: JSON.stringify(destination.config);
+							return {
+								ID: destination.id,
+								Type: destination.type,
+								URL: configDisplay,
+								Created: new Date(destination.created_at).toLocaleString(),
+							};
+						}
+					),
+					['ID', 'Type', 'URL', 'Created']
 				);
 			}
 		}

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

@@ -6,6 +6,7 @@ import { deleteSubcommand } from './delete';
 import { updateSubcommand } from './update';
 import destinationSubcommand from './destination';
 import deliverySubcommand from './delivery';
+import { statsSubcommand } from './stats';
 import { getCommand } from '../../../command-prefix';
 
 export const command = createCommand({
@@ -22,6 +23,7 @@ export const command = createCommand({
 		updateSubcommand,
 		destinationSubcommand,
 		deliverySubcommand,
+		statsSubcommand,
 	],
 	examples: [
 		{ command: getCommand('cloud schedule list'), description: 'List schedules' },
@@ -29,7 +31,10 @@ export const command = createCommand({
 			command: getCommand("cloud schedule create --name nightly --expression '0 0 * * *'"),
 			description: 'Create a schedule',
 		},
-		{ command: getCommand('cloud schedule get sched_abc123'), description: 'Get schedule details' },
+		{
+			command: getCommand('cloud schedule get sched_abc123'),
+			description: 'Get schedule details',
+		},
 	],
 });
 

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

@@ -25,8 +25,7 @@ export const listSubcommand = createCommand({
 	aliases: ['ls'],
 	description: 'List schedules',
 	tags: ['read-only', 'fast', 'requires-auth'],
-	requires: { auth: true, region: true },
-	optional: { project: true },
+	requires: { auth: true },
 	idempotent: true,
 	examples: [
 		{ command: getCommand('cloud schedule list'), description: 'List schedules' },
@@ -42,7 +41,7 @@ export const listSubcommand = createCommand({
 
 	async handler(ctx) {
 		const { opts, options } = ctx;
-		const schedule = createScheduleAdapter(ctx);
+		const schedule = await createScheduleAdapter(ctx);
 		const result = await schedule.list({ limit: opts.limit, offset: opts.offset });
 
 		if (!options.json) {
@@ -50,22 +49,24 @@ export const listSubcommand = createCommand({
 				tui.info('No schedules found');
 			} else {
 				tui.table(
-					result.schedules.map((item: {
-						id: string;
-						created_at: string;
-						updated_at: string;
-						created_by: string;
-						name: string;
-						description: string | null;
-						expression: string;
-						due_date: string;
-					}) => ({
-						Name: item.name,
-						ID: item.id,
-						Expression: item.expression,
-						'Next Due': item.due_date,
-						Created: new Date(item.created_at).toLocaleString(),
-					})),
+					result.schedules.map(
+						(item: {
+							id: string;
+							created_at: string;
+							updated_at: string;
+							created_by: string;
+							name: string;
+							description: string | null;
+							expression: string;
+							due_date: string;
+						}) => ({
+							Name: item.name,
+							ID: item.id,
+							Expression: item.expression,
+							'Next Due': item.due_date,
+							Created: new Date(item.created_at).toLocaleString(),
+						})
+					),
 					['Name', 'ID', 'Expression', 'Next Due', 'Created']
 				);
 			}

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

@@ -0,0 +1,72 @@
+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.schedule;
+	if (!svc) {
+		tui.info('No schedule data found.');
+		return;
+	}
+	tui.header('Schedule Statistics');
+	tui.newline();
+	console.log(`  ${tui.muted('Schedules:')}       ${formatNumber(svc.scheduleCount)}`);
+	console.log(
+		`  ${tui.muted('Deliveries:')}      ${formatNumber(svc.totalDeliveries)} (${svc.successDeliveries} ok, ${svc.failedDeliveries} failed)`
+	);
+}
+
+export const statsSubcommand = createCommand({
+	name: 'stats',
+	description: 'View schedule statistics',
+	tags: ['read-only', 'requires-auth'],
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('cloud schedule stats'),
+			description: 'View schedule 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: 'schedule',
+			start: opts.start,
+			end: opts.end,
+			orgIdHeader: orgId,
+		});
+
+		if (!options.json) {
+			displayStats(data);
+		}
+
+		return data;
+	},
+});
+
+export default statsSubcommand;

package/src/cmd/cloud/schedule/update.ts

@@ -21,8 +21,7 @@ export const updateSubcommand = createCommand({
 	name: 'update',
 	description: 'Update a schedule',
 	tags: ['mutating', 'requires-auth'],
-	requires: { auth: true, region: true },
-	optional: { project: true },
+	requires: { auth: true },
 	examples: [
 		{
 			command: getCommand("cloud schedule update sched_abc123 --expression '*/5 * * * *'"),
@@ -37,17 +36,18 @@ export const updateSubcommand = createCommand({
 			name: z.string().optional().describe('Schedule name'),
 			expression: z.string().optional().describe('Cron expression'),
 			description: z.string().optional().describe('Schedule description'),
+			clearDescription: z.boolean().optional().describe('Clear the schedule description'),
 		}),
 		response: ScheduleUpdateResponseSchema,
 	},
 
 	async handler(ctx) {
 		const { args, opts, options } = ctx;
-		const schedule = createScheduleAdapter(ctx);
+		const schedule = await createScheduleAdapter(ctx);
 		const result = await schedule.update(args.schedule_id, {
 			name: opts.name,
 			expression: opts.expression,
-			description: opts.description,
+			description: opts.clearDescription ? '' : opts.description,
 		});
 
 		if (!options.json) {
@@ -58,7 +58,7 @@ export const updateSubcommand = createCommand({
 						Name: result.schedule.name,
 						ID: result.schedule.id,
 						Expression: result.schedule.expression,
-						Description: result.schedule.description ?? '-',
+						Description: result.schedule.description || '-',
 						Updated: new Date(result.schedule.updated_at).toLocaleString(),
 					},
 				],

package/src/cmd/cloud/schedule/util.ts

@@ -1,34 +1,28 @@
 import { ScheduleService, type Logger } from '@agentuity/core';
 import { createServerFetchAdapter } from '@agentuity/server';
-import type { AuthData, Config, GlobalOptions, ProjectConfig } from '../../../types';
+import type { AuthData, Config, GlobalOptions } from '../../../types';
 import { getCatalystUrl } from '../../../catalyst';
+import { defaultProfileName, getDefaultRegion } from '../../../config';
 import * as tui from '../../../tui';
 
-export function createScheduleAdapter(
-	ctx: {
-		logger: Logger;
-		auth: AuthData;
-		region: string;
-		project?: ProjectConfig;
-		config: Config | null;
-		options: GlobalOptions;
-	},
-	explicitOrgId?: string
-) {
+export interface ScheduleContext {
+	logger: Logger;
+	auth: AuthData;
+	config: Config | null;
+	options: GlobalOptions;
+}
+
+export async function createScheduleAdapter(ctx: ScheduleContext) {
 	const orgId =
-		explicitOrgId ??
-		ctx.project?.orgId ??
-		ctx.options.orgId ??
-		(process.env.AGENTUITY_CLOUD_ORG_ID || ctx.config?.preferences?.orgId);
+		ctx.options.orgId ?? (process.env.AGENTUITY_CLOUD_ORG_ID || ctx.config?.preferences?.orgId);
 	if (!orgId) {
-		tui.fatal(
-			'Organization ID is required. Either run from a project directory or use --org-id flag.'
-		);
+		tui.fatal('Organization ID is required. Use --org-id flag or set AGENTUITY_CLOUD_ORG_ID.');
 	}
 	const adapter = createServerFetchAdapter(
 		{ headers: { Authorization: `Bearer ${ctx.auth.apiKey}`, 'x-agentuity-orgid': orgId } },
 		ctx.logger
 	);
-	const baseUrl = getCatalystUrl(ctx.region);
+	const region = await getDefaultRegion(ctx.config?.name ?? defaultProfileName, ctx.config);
+	const baseUrl = getCatalystUrl(region);
 	return new ScheduleService(baseUrl, adapter);
 }

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

@@ -0,0 +1,11 @@
+import { createCommand } from '../../../types';
+import { statsSubcommand } from './stats';
+
+const servicesCommand = createCommand({
+	name: 'services',
+	description: 'Service usage statistics',
+	tags: ['read-only', 'requires-auth'],
+	subcommands: [statsSubcommand],
+});
+
+export default servicesCommand;

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

@@ -0,0 +1,199 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getGlobalCatalystAPIClient } from '../../../config';
+import { getCommand } from '../../../command-prefix';
+import {
+	getServiceStats,
+	VALID_SERVICES,
+	type ServiceName,
+	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 formatLatency(ms: number): string {
+	if (ms >= 1000) return `${(ms / 1000).toFixed(1)}s`;
+	return `${Math.round(ms)}ms`;
+}
+
+function displayServiceStats(data: ServiceStatsData): void {
+	tui.header('Service Statistics');
+
+	const services = data.services;
+	let hasData = false;
+
+	if (services.keyvalue) {
+		hasData = true;
+		tui.newline();
+		console.log(tui.colorPrimary('Key-Value:'));
+		console.log(
+			`  ${tui.muted('Namespaces:')}      ${formatNumber(services.keyvalue.namespaceCount)}`
+		);
+		console.log(`  ${tui.muted('Keys:')}            ${formatNumber(services.keyvalue.keyCount)}`);
+		console.log(
+			`  ${tui.muted('Total Size:')}      ${tui.formatBytes(services.keyvalue.totalSizeBytes)}`
+		);
+	}
+
+	if (services.vector) {
+		hasData = true;
+		tui.newline();
+		console.log(tui.colorPrimary('Vector:'));
+		console.log(
+			`  ${tui.muted('Namespaces:')}      ${formatNumber(services.vector.namespaceCount)}`
+		);
+		console.log(
+			`  ${tui.muted('Documents:')}       ${formatNumber(services.vector.documentCount)}`
+		);
+		console.log(
+			`  ${tui.muted('Total Size:')}      ${tui.formatBytes(services.vector.totalSizeBytes)}`
+		);
+	}
+
+	if (services.queue) {
+		hasData = true;
+		tui.newline();
+		console.log(tui.colorPrimary('Queue:'));
+		console.log(`  ${tui.muted('Queues:')}          ${formatNumber(services.queue.queueCount)}`);
+		console.log(
+			`  ${tui.muted('Total Messages:')}  ${formatNumber(services.queue.totalMessages)}`
+		);
+		console.log(`  ${tui.muted('DLQ Messages:')}    ${formatNumber(services.queue.totalDlq)}`);
+	}
+
+	if (services.stream) {
+		hasData = true;
+		tui.newline();
+		console.log(tui.colorPrimary('Stream:'));
+		console.log(
+			`  ${tui.muted('Streams:')}         ${formatNumber(services.stream.streamCount)}`
+		);
+		console.log(
+			`  ${tui.muted('Total Size:')}      ${tui.formatBytes(services.stream.totalSizeBytes)}`
+		);
+	}
+
+	if (services.sandbox) {
+		hasData = true;
+		const sb = services.sandbox;
+		tui.newline();
+		console.log(tui.colorPrimary('Sandbox:'));
+		console.log(
+			`  ${tui.muted('Active:')}          ${formatNumber(sb.totalActive)} (${sb.running} running, ${sb.idle} idle, ${sb.creating} creating)`
+		);
+		console.log(`  ${tui.muted('Executions:')}      ${formatNumber(sb.totalExecutions)}`);
+		console.log(`  ${tui.muted('CPU Time:')}        ${formatLatency(sb.totalCpuTimeMs)}`);
+		console.log(`  ${tui.muted('Memory:')}          ${tui.formatBytes(sb.totalMemoryByteSec)}`);
+		console.log(
+			`  ${tui.muted('Network Out:')}     ${tui.formatBytes(sb.totalNetworkEgressBytes)}`
+		);
+	}
+
+	if (services.email) {
+		hasData = true;
+		const em = services.email;
+		tui.newline();
+		console.log(tui.colorPrimary('Email:'));
+		console.log(`  ${tui.muted('Addresses:')}       ${formatNumber(em.addressCount)}`);
+		console.log(`  ${tui.muted('Inbound:')}         ${formatNumber(em.inboundCount)}`);
+		console.log(
+			`  ${tui.muted('Outbound:')}        ${formatNumber(em.outboundCount)} (${em.outboundSuccess} ok, ${em.outboundFailed} failed)`
+		);
+	}
+
+	if (services.task) {
+		hasData = true;
+		const tk = services.task;
+		tui.newline();
+		console.log(tui.colorPrimary('Task:'));
+		console.log(`  ${tui.muted('Total:')}           ${formatNumber(tk.total)}`);
+		console.log(`  ${tui.muted('Open:')}            ${formatNumber(tk.open)}`);
+		console.log(`  ${tui.muted('In Progress:')}     ${formatNumber(tk.inProgress)}`);
+		console.log(`  ${tui.muted('Closed:')}          ${formatNumber(tk.closed)}`);
+	}
+
+	if (services.schedule) {
+		hasData = true;
+		const sc = services.schedule;
+		tui.newline();
+		console.log(tui.colorPrimary('Schedule:'));
+		console.log(`  ${tui.muted('Schedules:')}       ${formatNumber(sc.scheduleCount)}`);
+		console.log(
+			`  ${tui.muted('Deliveries:')}      ${formatNumber(sc.totalDeliveries)} (${sc.successDeliveries} ok, ${sc.failedDeliveries} failed)`
+		);
+	}
+
+	if (services.database) {
+		hasData = true;
+		const db = services.database;
+		tui.newline();
+		console.log(tui.colorPrimary('Database:'));
+		console.log(`  ${tui.muted('Databases:')}       ${formatNumber(db.databaseCount)}`);
+		console.log(`  ${tui.muted('Tables:')}          ${formatNumber(db.totalTableCount)}`);
+		console.log(`  ${tui.muted('Records:')}         ${formatNumber(db.totalRecordCount)}`);
+		console.log(`  ${tui.muted('Total Size:')}      ${tui.formatBytes(db.totalSizeBytes)}`);
+	}
+
+	if (!hasData) {
+		tui.info('No service usage data found.');
+	}
+}
+
+export const statsSubcommand = createCommand({
+	name: 'stats',
+	description: 'View service usage statistics',
+	tags: ['read-only', 'requires-auth'],
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('cloud services stats'),
+			description: 'View stats for all services',
+		},
+		{
+			command: getCommand('cloud services stats --service keyvalue'),
+			description: 'View stats for key-value service only',
+		},
+	],
+	schema: {
+		options: z.object({
+			service: z
+				.string()
+				.optional()
+				.describe(`Service name to filter (${VALID_SERVICES.join(', ')})`),
+			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: opts.service as ServiceName,
+			start: opts.start,
+			end: opts.end,
+			orgIdHeader: orgId,
+		});
+
+		if (!options.json) {
+			displayServiceStats(data);
+		}
+
+		return data;
+	},
+});
+
+export default statsSubcommand;

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

@@ -3,6 +3,7 @@ import createSubcommand from './create';
 import listSubcommand from './list';
 import getSubcommand from './get';
 import deleteSubcommand from './delete';
+import statsSubcommand from './stats';
 import { getCommand } from '../../../command-prefix';
 
 export const streamCommand = createCommand({
@@ -22,7 +23,13 @@ export const streamCommand = createCommand({
 		{ command: getCommand('cloud stream list'), description: 'List all streams' },
 		{ command: getCommand('cloud stream get <id>'), description: 'Get stream details' },
 	],
-	subcommands: [createSubcommand, listSubcommand, getSubcommand, deleteSubcommand],
+	subcommands: [
+		createSubcommand,
+		listSubcommand,
+		getSubcommand,
+		deleteSubcommand,
+		statsSubcommand,
+	],
 });
 
 export default streamCommand;

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

@@ -0,0 +1,70 @@
+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.stream;
+	if (!svc) {
+		tui.info('No stream data found.');
+		return;
+	}
+	tui.header('Stream Statistics');
+	tui.newline();
+	console.log(`  ${tui.muted('Streams:')}         ${formatNumber(svc.streamCount)}`);
+	console.log(`  ${tui.muted('Total Size:')}      ${tui.formatBytes(svc.totalSizeBytes)}`);
+}
+
+export const statsSubcommand = createCommand({
+	name: 'stats',
+	description: 'View stream statistics',
+	tags: ['read-only', 'requires-auth'],
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('cloud stream stats'),
+			description: 'View stream 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: 'stream',
+			start: opts.start,
+			end: opts.end,
+			orgIdHeader: orgId,
+		});
+
+		if (!options.json) {
+			displayStats(data);
+		}
+
+		return data;
+	},
+});
+
+export default statsSubcommand;