@agentuity/cli 1.0.22 → 1.0.24

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

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createScheduleAdapter } from './util';
+import { getCommand } from '../../../command-prefix';
+
+const ScheduleUpdateResponseSchema = z.object({
+	schedule: z.object({
+		id: z.string(),
+		created_at: z.string(),
+		updated_at: z.string(),
+		created_by: z.string(),
+		name: z.string(),
+		description: z.string().nullable(),
+		expression: z.string(),
+		due_date: z.string(),
+	}),
+});
+
+export const updateSubcommand = createCommand({
+	name: 'update',
+	description: 'Update a schedule',
+	tags: ['mutating', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand("cloud schedule update sched_abc123 --expression '*/5 * * * *'"),
+			description: 'Update schedule expression',
+		},
+	],
+	schema: {
+		args: z.object({
+			schedule_id: z.string().min(1).describe('Schedule ID'),
+		}),
+		options: z.object({
+			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 = await createScheduleAdapter(ctx);
+		const result = await schedule.update(args.schedule_id, {
+			name: opts.name,
+			expression: opts.expression,
+			description: opts.clearDescription ? '' : opts.description,
+		});
+
+		if (!options.json) {
+			tui.success(`Updated schedule: ${result.schedule.name}`);
+			tui.table(
+				[
+					{
+						Name: result.schedule.name,
+						ID: result.schedule.id,
+						Expression: result.schedule.expression,
+						Description: result.schedule.description || '-',
+						Updated: new Date(result.schedule.updated_at).toLocaleString(),
+					},
+				],
+				undefined,
+				{ layout: 'vertical' }
+			);
+		}
+
+		return result;
+	},
+});
+
+export default updateSubcommand;

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

@@ -0,0 +1,29 @@
+import { ScheduleService, type Logger } from '@agentuity/core';
+import { createServerFetchAdapter } from '@agentuity/server';
+import type { AuthData, Config, GlobalOptions } from '../../../types';
+import { getCatalystUrl } from '../../../catalyst';
+import { defaultProfileName, getDefaultRegion } from '../../../config';
+import * as tui from '../../../tui';
+
+export interface ScheduleContext {
+	logger: Logger;
+	auth: AuthData;
+	config: Config | null;
+	options: GlobalOptions;
+}
+
+export async function createScheduleAdapter(ctx: ScheduleContext) {
+	const orgId =
+		ctx.options.orgId ??
+		(process.env.AGENTUITY_CLOUD_ORG_ID || ctx.config?.preferences?.orgId);
+	if (!orgId) {
+		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 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

@@ -0,0 +1,123 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createStorageAdapter, parseMetadataFlag, cacheTaskId } from './util';
+import { getCommand } from '../../../command-prefix';
+import type { TaskPriority, TaskStatus, TaskType } from '@agentuity/core';
+
+const TaskCreateResponseSchema = z.object({
+	success: z.boolean().describe('Whether the operation succeeded'),
+	task: z.object({
+		id: z.string().describe('Task ID'),
+		title: z.string().describe('Task title'),
+		type: z.string().describe('Task type'),
+		status: z.string().describe('Task status'),
+		priority: z.string().describe('Task priority'),
+		created_at: z.string().describe('Creation timestamp'),
+	}),
+	durationMs: z.number().describe('Operation duration in milliseconds'),
+});
+
+export const createSubcommand = createCommand({
+	name: 'create',
+	aliases: ['new', 'add'],
+	description: 'Create a new task',
+	tags: ['mutating', 'slow', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud task create "Fix login bug" --type bug --created-id agent_001'),
+			description: 'Create a bug task',
+		},
+		{
+			command: getCommand(
+				'cloud task create "Add dark mode" --type feature --created-id agent_001 --priority high --description "Implement dark mode toggle"'
+			),
+			description: 'Create a feature with priority and description',
+		},
+		{
+			command: getCommand(
+				'cloud task create "Q1 Planning" --type epic --created-id agent_001 --metadata \'{"team":"engineering"}\''
+			),
+			description: 'Create an epic with metadata',
+		},
+	],
+	schema: {
+		args: z.object({
+			title: z.string().min(1).describe('the task title'),
+		}),
+		options: z.object({
+			type: z.enum(['epic', 'feature', 'enhancement', 'bug', 'task']).describe('the task type'),
+			createdId: z.string().min(1).describe('the ID of the creator (agent or user)'),
+			description: z.string().optional().describe('task description'),
+			priority: z
+				.enum(['high', 'medium', 'low', 'none'])
+				.optional()
+				.describe('task priority (default: none)'),
+			status: z
+				.enum(['open', 'in_progress', 'closed'])
+				.optional()
+				.describe('initial task status (default: open)'),
+			parentId: z.string().optional().describe('parent task ID for subtasks'),
+			assignedId: z.string().optional().describe('ID of the assigned agent or user'),
+			metadata: z.string().optional().describe('JSON metadata object'),
+		}),
+		response: TaskCreateResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const started = Date.now();
+		const storage = await createStorageAdapter(ctx);
+
+		const metadata = parseMetadataFlag(opts.metadata);
+
+		const task = await storage.create({
+			title: args.title,
+			type: opts.type as TaskType,
+			created_id: opts.createdId,
+			description: opts.description,
+			priority: opts.priority as TaskPriority,
+			status: opts.status as TaskStatus,
+			parent_id: opts.parentId,
+			assigned_id: opts.assignedId,
+			metadata,
+		});
+
+		const durationMs = Date.now() - started;
+		await cacheTaskId(ctx, task.id);
+
+		if (!options.json) {
+			tui.success(`Task created: ${tui.bold(task.id)}`);
+
+			const tableData: Record<string, string> = {
+				Title: task.title,
+				Type: task.type,
+				Status: task.status,
+				Priority: task.priority,
+				Created: new Date(task.created_at).toLocaleString(),
+			};
+
+			if (task.description) {
+				tableData['Description'] = task.description;
+			}
+
+			tui.table([tableData], Object.keys(tableData), { layout: 'vertical', padStart: '  ' });
+		}
+
+		return {
+			success: true,
+			task: {
+				id: task.id,
+				title: task.title,
+				type: task.type,
+				status: task.status,
+				priority: task.priority,
+				created_at: task.created_at,
+			},
+			durationMs,
+		};
+	},
+});
+
+export default createSubcommand;

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

@@ -0,0 +1,139 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createStorageAdapter, cacheTaskId } from './util';
+import { getCommand } from '../../../command-prefix';
+
+const TaskGetResponseSchema = z.object({
+	success: z.boolean().describe('Whether the operation succeeded'),
+	task: z.object({
+		id: z.string().describe('Task ID'),
+		title: z.string().describe('Task title'),
+		description: z.string().optional().describe('Task description'),
+		type: z.string().describe('Task type'),
+		status: z.string().describe('Task status'),
+		priority: z.string().describe('Task priority'),
+		parent_id: z.string().optional().describe('Parent task ID'),
+		assigned_id: z.string().optional().describe('Assigned agent or user ID'),
+		created_id: z.string().describe('Creator ID'),
+		closed_id: z.string().optional().describe('Closer ID'),
+		metadata: z.record(z.string(), z.unknown()).optional().describe('Task metadata'),
+		created_at: z.string().describe('Creation timestamp'),
+		updated_at: z.string().describe('Last update timestamp'),
+		open_date: z.string().optional().describe('Date task was opened'),
+		in_progress_date: z.string().optional().describe('Date task moved to in-progress'),
+		closed_date: z.string().optional().describe('Date task was closed'),
+	}),
+	durationMs: z.number().describe('Operation duration in milliseconds'),
+});
+
+export const getSubcommand = createCommand({
+	name: 'get',
+	aliases: ['show', 'info'],
+	description: 'Get details of a task by ID',
+	tags: ['read-only', 'slow', 'requires-auth'],
+	idempotent: true,
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud task get task_abc123'),
+			description: 'Get task details',
+		},
+		{
+			command: getCommand('cloud task get task_abc123 --json'),
+			description: 'Get task details as JSON',
+		},
+	],
+	schema: {
+		args: z.object({
+			id: z.string().min(1).describe('the task ID to get'),
+		}),
+		response: TaskGetResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const started = Date.now();
+		const storage = await createStorageAdapter(ctx);
+
+		const task = await storage.get(args.id);
+		const durationMs = Date.now() - started;
+
+		if (!task) {
+			tui.fatal(`Task not found: ${args.id}`);
+		}
+
+		await cacheTaskId(ctx, task.id);
+
+		if (!options.json) {
+			const tableData: Record<string, string> = {
+				ID: task.id,
+				Title: task.title,
+				Type: task.type,
+				Status: task.status,
+				Priority: task.priority,
+			};
+
+			if (task.description) {
+				tableData['Description'] = task.description;
+			}
+
+			tableData['Creator'] = task.created_id;
+
+			if (task.assigned_id) {
+				tableData['Assigned'] = task.assigned_id;
+			}
+			if (task.parent_id) {
+				tableData['Parent'] = task.parent_id;
+			}
+			if (task.closed_id) {
+				tableData['Closed By'] = task.closed_id;
+			}
+
+			tableData['Created'] = new Date(task.created_at).toLocaleString();
+			tableData['Updated'] = new Date(task.updated_at).toLocaleString();
+
+			if (task.open_date) {
+				tableData['Opened'] = new Date(task.open_date).toLocaleString();
+			}
+			if (task.in_progress_date) {
+				tableData['In Progress'] = new Date(task.in_progress_date).toLocaleString();
+			}
+			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) {
+				tui.newline();
+				tui.header('Metadata');
+				tui.json(task.metadata);
+			}
+		}
+
+		return {
+			success: true,
+			task: {
+				id: task.id,
+				title: task.title,
+				description: task.description,
+				type: task.type,
+				status: task.status,
+				priority: task.priority,
+				parent_id: task.parent_id,
+				assigned_id: task.assigned_id,
+				created_id: task.created_id,
+				closed_id: task.closed_id,
+				metadata: task.metadata,
+				created_at: task.created_at,
+				updated_at: task.updated_at,
+				open_date: task.open_date,
+				in_progress_date: task.in_progress_date,
+				closed_date: task.closed_date,
+			},
+			durationMs,
+		};
+	},
+});
+
+export default getSubcommand;