@agentuity/cli 1.0.23 → 1.0.24

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

@@ -0,0 +1,74 @@
+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,29 @@
 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);
 	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,225 @@
+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,7 @@ 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,74 @@
+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;

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

@@ -24,7 +24,6 @@ export const createSubcommand = createCommand({
 	description: 'Create a new task',
 	tags: ['mutating', 'slow', 'requires-auth'],
 	requires: { auth: true },
-	optional: { project: true },
 	examples: [
 		{
 			command: getCommand('cloud task create "Fix login bug" --type bug --created-id agent_001'),

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

@@ -34,7 +34,6 @@ export const getSubcommand = createCommand({
 	tags: ['read-only', 'slow', 'requires-auth'],
 	idempotent: true,
 	requires: { auth: true },
-	optional: { project: true },
 	examples: [
 		{
 			command: getCommand('cloud task get task_abc123'),
@@ -103,11 +102,13 @@ export const getSubcommand = createCommand({
 			if (task.closed_date) {
 				tableData['Closed'] = new Date(task.closed_date).toLocaleString();
 			}
+			tui.table([tableData], Object.keys(tableData), { layout: 'vertical', padStart: '  ' });
+
 			if (task.metadata && Object.keys(task.metadata).length > 0) {
-				tableData['Metadata'] = JSON.stringify(task.metadata);
+				tui.newline();
+				tui.header('Metadata');
+				tui.json(task.metadata);
 			}
-
-			tui.table([tableData], Object.keys(tableData), { layout: 'vertical', padStart: '  ' });
 		}
 
 		return {

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

@@ -3,6 +3,7 @@ import { getSubcommand } from './get';
 import { createSubcommand } from './create';
 import { updateSubcommand } from './update';
 import { listSubcommand } from './list';
+import { statsSubcommand } from './stats';
 import { getCommand } from '../../../command-prefix';
 
 export const taskCommand = createCommand({
@@ -27,7 +28,7 @@ export const taskCommand = createCommand({
 			description: 'Update task status',
 		},
 	],
-	subcommands: [getSubcommand, createSubcommand, updateSubcommand, listSubcommand],
+	subcommands: [getSubcommand, createSubcommand, updateSubcommand, listSubcommand, statsSubcommand],
 	requires: { auth: true },
 });
 

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

@@ -59,7 +59,6 @@ export const listSubcommand = createCommand({
 	description: 'List tasks with optional filtering and sorting',
 	tags: ['read-only', 'slow', 'requires-auth'],
 	requires: { auth: true },
-	optional: { project: true },
 	idempotent: true,
 	pagination: {
 		supported: true,
@@ -163,7 +162,7 @@ export const listSubcommand = createCommand({
 				]);
 
 				tui.info(
-					`\nShowing ${result.tasks.length} of ${result.total} ${tui.plural(result.total, 'task', 'tasks')} (${durationMs.toFixed(1)}ms)`
+					`Showing ${result.tasks.length} of ${result.total} ${tui.plural(result.total, 'task', 'tasks')} (${durationMs.toFixed(1)}ms)`
 				);
 			}
 		}

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

@@ -0,0 +1,74 @@
+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.task;
+	if (!svc) {
+		tui.info('No task data found.');
+		return;
+	}
+	tui.header('Task Statistics');
+	tui.newline();
+	console.log(`  ${tui.muted('Total:')}           ${formatNumber(svc.total)}`);
+	console.log(`  ${tui.muted('Open:')}            ${formatNumber(svc.open)}`);
+	console.log(
+		`  ${tui.muted('In Progress:')}     ${formatNumber(svc.inProgress)}`
+	);
+	console.log(`  ${tui.muted('Closed:')}          ${formatNumber(svc.closed)}`);
+}
+
+export const statsSubcommand = createCommand({
+	name: 'stats',
+	description: 'View task statistics',
+	tags: ['read-only', 'requires-auth'],
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('cloud task stats'),
+			description: 'View task 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: 'task',
+			start: opts.start,
+			end: opts.end,
+			orgIdHeader: orgId,
+		});
+
+		if (!options.json) {
+			displayStats(data);
+		}
+
+		return data;
+	},
+});
+
+export default statsSubcommand;

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

@@ -24,7 +24,6 @@ export const updateSubcommand = createCommand({
 	description: 'Update an existing task',
 	tags: ['mutating', 'slow', 'requires-auth'],
 	requires: { auth: true },
-	optional: { project: true },
 	examples: [
 		{
 			command: getCommand('cloud task update task_abc123 --status in_progress'),