@agentuity/cli 1.0.22 → 1.0.24

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

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+import { createCommand } from '../../../../types';
+import * as tui from '../../../../tui';
+import { createScheduleAdapter } from '../util';
+import { getCommand } from '../../../../command-prefix';
+
+const DeliveryListResponseSchema = z.object({
+	deliveries: z.array(
+		z.object({
+			id: z.string(),
+			date: z.string(),
+			schedule_id: z.string(),
+			schedule_destination_id: z.string(),
+			status: z.enum(['pending', 'success', 'failed']),
+			retries: z.number(),
+			error: z.string().nullable(),
+			response: z.record(z.string(), z.unknown()).nullable(),
+		})
+	),
+});
+
+export const listSubcommand = createCommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List deliveries for a schedule',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true },
+	idempotent: true,
+	examples: [
+		{
+			command: getCommand('cloud schedule delivery list sched_abc123 --limit 50'),
+			description: 'List schedule deliveries',
+		},
+	],
+	schema: {
+		args: z.object({
+			schedule_id: z.string().min(1).describe('Schedule ID'),
+		}),
+		options: z.object({
+			limit: z.coerce.number().min(0).optional().describe('Maximum number of deliveries'),
+			offset: z.coerce.number().min(0).optional().describe('Pagination offset'),
+		}),
+		response: DeliveryListResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const schedule = await createScheduleAdapter(ctx);
+		const result = await schedule.listDeliveries(args.schedule_id, {
+			limit: opts.limit,
+			offset: opts.offset,
+		});
+
+		if (!options.json) {
+			if (result.deliveries.length === 0) {
+				tui.info('No deliveries found');
+			} else {
+				tui.table(
+					result.deliveries.map((delivery: {
+						id: string;
+						date: string;
+						status: 'pending' | 'success' | 'failed';
+						retries: number;
+						schedule_destination_id: string;
+					}) => ({
+						ID: delivery.id,
+						Date: new Date(delivery.date).toLocaleString(),
+						Status: delivery.status,
+						Retries: delivery.retries,
+						'Destination ID': delivery.schedule_destination_id,
+					})),
+					['ID', 'Date', 'Status', 'Retries', 'Destination ID']
+				);
+			}
+		}
+
+		return result;
+	},
+});
+
+export default listSubcommand;

package/src/cmd/cloud/schedule/destination/create.ts

@@ -0,0 +1,114 @@
+import { z } from 'zod';
+import { createCommand } from '../../../../types';
+import * as tui from '../../../../tui';
+import { createScheduleAdapter } from '../util';
+import { getCommand } from '../../../../command-prefix';
+
+const CreateDestinationResponseSchema = z.object({
+	destination: z.object({
+		id: z.string(),
+		schedule_id: z.string(),
+		created_at: z.string(),
+		updated_at: z.string(),
+		created_by: z.string(),
+		type: z.enum(['url', 'sandbox']),
+		config: z.record(z.string(), z.unknown()),
+	}),
+});
+
+export const createSubcommand = createCommand({
+	name: 'create',
+	description: 'Create destination for a schedule',
+	tags: ['mutating', 'creates-resource', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud schedule destination create url sched_abc123 https://example.com'),
+			description: 'Create URL destination',
+		},
+		{
+			command: getCommand('cloud schedule destination create url sched_abc123 https://example.com --method POST'),
+			description: 'Create URL destination with POST method',
+		},
+	],
+	schema: {
+		args: z.object({
+			type: z.enum(['url', 'sandbox']).describe('Destination type (url or sandbox)'),
+			schedule_id: z.string().min(1).describe('Schedule ID'),
+			target: z.string().min(1).describe('Destination URL or sandbox ID'),
+		}),
+		options: z.object({
+			method: z.string().optional().describe('HTTP method for URL destination'),
+			timeout: z.coerce.number().optional().describe('Request timeout in milliseconds'),
+			config: z.string().optional().describe('Additional config as JSON object'),
+		}),
+		response: CreateDestinationResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const schedule = await createScheduleAdapter(ctx);
+
+		if (args.type === 'sandbox' && !args.target.startsWith('sbx_')) {
+			tui.fatal('Sandbox target must start with "sbx_"');
+		}
+		if (args.type === 'url' && !args.target.startsWith('http://') && !args.target.startsWith('https://')) {
+			tui.fatal('URL target must start with http:// or https://');
+		}
+
+		let parsedConfig: Record<string, unknown> = {};
+		if (opts.config) {
+			try {
+				parsedConfig = JSON.parse(opts.config) as Record<string, unknown>;
+			} catch (e) {
+				tui.fatal(`Invalid JSON in --config: ${e instanceof Error ? e.message : String(e)}`);
+			}
+		}
+
+		const config: Record<string, unknown> = {
+			...parsedConfig,
+		};
+
+		if (args.type === 'url') {
+			config.url = args.target;
+		}
+		if (args.type === 'sandbox') {
+			config.sandbox_id = args.target;
+		}
+		if (opts.method && args.type === 'url') {
+			config.method = opts.method;
+		}
+		if (opts.timeout !== undefined && args.type === 'url') {
+			config.timeout = opts.timeout;
+		}
+
+		const result = await schedule.createDestination(args.schedule_id, {
+			type: args.type,
+			config,
+		});
+
+		if (!options.json) {
+			tui.success(`Created destination: ${result.destination.id}`);
+			tui.table(
+				[
+					{
+						ID: result.destination.id,
+						Type: result.destination.type,
+					},
+				],
+				undefined,
+				{ layout: 'vertical' }
+			);
+
+			if (result.destination.config && Object.keys(result.destination.config).length > 0) {
+				tui.newline();
+				tui.header('Config');
+				tui.json(result.destination.config);
+			}
+		}
+
+		return result;
+	},
+});
+
+export default createSubcommand;

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

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { createCommand } from '../../../../types';
+import * as tui from '../../../../tui';
+import { createScheduleAdapter } from '../util';
+import { getCommand } from '../../../../command-prefix';
+
+const DestinationDeleteResponseSchema = z.object({
+	success: z.boolean(),
+	destination_id: z.string(),
+});
+
+export const deleteSubcommand = createCommand({
+	name: 'delete',
+	aliases: ['rm'],
+	description: 'Delete a destination',
+	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth'],
+	requires: { auth: true },
+	idempotent: true,
+	examples: [
+		{
+			command: getCommand('cloud schedule destination delete sdest_abc456'),
+			description: 'Delete destination',
+		},
+	],
+	schema: {
+		args: z.object({
+			destination_id: z.string().min(1).describe('Destination ID'),
+		}),
+		response: DestinationDeleteResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const schedule = await createScheduleAdapter(ctx);
+		await schedule.deleteDestination(args.destination_id);
+
+		if (!options.json) {
+			tui.success(`Deleted destination: ${args.destination_id}`);
+		}
+
+		return { success: true, destination_id: args.destination_id };
+	},
+});
+
+export default deleteSubcommand;

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

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import { createCommand } from '../../../../types';
+import * as tui from '../../../../tui';
+import { createScheduleAdapter } from '../util';
+import { getCommand } from '../../../../command-prefix';
+
+const DestinationGetResponseSchema = z.object({
+	destination: z.object({
+		id: z.string(),
+		schedule_id: z.string(),
+		created_at: z.string(),
+		updated_at: z.string(),
+		created_by: z.string(),
+		type: z.enum(['url', 'sandbox']),
+		config: z.record(z.string(), z.unknown()),
+	}),
+});
+
+export const getSubcommand = createCommand({
+	name: 'get',
+	description: 'Get destination details',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true },
+	idempotent: true,
+	examples: [
+		{
+			command: getCommand('cloud schedule destination get sched_abc123 sdest_abc456'),
+			description: 'Get destination details',
+		},
+	],
+	schema: {
+		args: z.object({
+			schedule_id: z.string().min(1).describe('Schedule ID'),
+			destination_id: z.string().min(1).describe('Destination ID'),
+		}),
+		response: DestinationGetResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const schedule = await createScheduleAdapter(ctx);
+		const destination = await schedule.getDestination(args.schedule_id, args.destination_id);
+
+		if (!options.json) {
+			const details: Record<string, unknown> = {
+				ID: destination.id,
+				'Schedule ID': destination.schedule_id,
+				Type: destination.type,
+				Created: new Date(destination.created_at).toLocaleString(),
+				Updated: new Date(destination.updated_at).toLocaleString(),
+			};
+
+			tui.table([details], undefined, { layout: 'vertical' });
+
+			if (destination.config && Object.keys(destination.config).length > 0) {
+				tui.newline();
+				tui.header('Config');
+				tui.json(destination.config);
+			}
+		}
+
+		return { destination };
+	},
+});
+
+export default getSubcommand;

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

@@ -0,0 +1,27 @@
+import { createCommand } from '../../../../types';
+import { createSubcommand } from './create';
+import { listSubcommand } from './list';
+import { getSubcommand } from './get';
+import { deleteSubcommand } from './delete';
+import { getCommand } from '../../../../command-prefix';
+
+export const command = createCommand({
+	name: 'destination',
+	aliases: ['dest'],
+	description: 'Manage schedule destinations',
+	tags: ['requires-auth'],
+	requires: { auth: true },
+	subcommands: [createSubcommand, listSubcommand, getSubcommand, deleteSubcommand],
+	examples: [
+		{
+			command: getCommand('cloud schedule destination list sched_abc123'),
+			description: 'List destinations',
+		},
+		{
+			command: getCommand('cloud schedule destination create url sched_abc123 https://example.com'),
+			description: 'Create URL destination',
+		},
+	],
+});
+
+export default command;

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

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+import { createCommand } from '../../../../types';
+import * as tui from '../../../../tui';
+import { createScheduleAdapter } from '../util';
+import { getCommand } from '../../../../command-prefix';
+
+const DestinationListResponseSchema = z.object({
+	destinations: z.array(
+		z.object({
+			id: z.string(),
+			schedule_id: z.string(),
+			created_at: z.string(),
+			updated_at: z.string(),
+			created_by: z.string(),
+			type: z.enum(['url', 'sandbox']),
+			config: z.record(z.string(), z.unknown()),
+		})
+	),
+});
+
+export const listSubcommand = createCommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List destinations for a schedule',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true },
+	idempotent: true,
+	examples: [
+		{
+			command: getCommand('cloud schedule destination list sched_abc123'),
+			description: 'List schedule destinations',
+		},
+	],
+	schema: {
+		args: z.object({
+			schedule_id: z.string().min(1).describe('Schedule ID'),
+		}),
+		response: DestinationListResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const schedule = await createScheduleAdapter(ctx);
+		const result = await schedule.get(args.schedule_id);
+
+		if (!options.json) {
+			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;
+					}) => {
+						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']
+				);
+			}
+		}
+
+		return { destinations: result.destinations };
+	},
+});
+
+export default listSubcommand;

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

@@ -0,0 +1,97 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createScheduleAdapter } from './util';
+import { getCommand } from '../../../command-prefix';
+
+const ScheduleGetResponseSchema = 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(),
+	}),
+	destinations: z.array(
+		z.object({
+			id: z.string(),
+			schedule_id: z.string(),
+			created_at: z.string(),
+			updated_at: z.string(),
+			created_by: z.string(),
+			type: z.enum(['url', 'sandbox']),
+			config: z.record(z.string(), z.unknown()),
+		})
+	),
+});
+
+export const getSubcommand = createCommand({
+	name: 'get',
+	description: 'Get schedule details',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true },
+	idempotent: true,
+		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'),
+		}),
+		response: ScheduleGetResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const schedule = await createScheduleAdapter(ctx);
+		const result = await schedule.get(args.schedule_id);
+
+		if (!options.json) {
+			const details: Record<string, unknown> = {
+				Name: result.schedule.name,
+				ID: result.schedule.id,
+				Expression: result.schedule.expression,
+				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(),
+			};
+
+			tui.table([details], undefined, { layout: 'vertical', padStart: '  ' });
+
+			tui.newline();
+			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;
+					}) => {
+						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']
+				);
+			}
+		}
+
+		return result;
+	},
+});
+
+export default getSubcommand;

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

@@ -0,0 +1,38 @@
+import { createCommand } from '../../../types';
+import { listSubcommand } from './list';
+import { createSubcommand } from './create';
+import { getSubcommand } from './get';
+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({
+	name: 'schedule',
+	aliases: ['schedules', 'sched'],
+	description: 'Manage scheduled tasks',
+	tags: ['requires-auth'],
+	requires: { auth: true },
+	subcommands: [
+		listSubcommand,
+		createSubcommand,
+		getSubcommand,
+		deleteSubcommand,
+		updateSubcommand,
+		destinationSubcommand,
+		deliverySubcommand,
+		statsSubcommand,
+	],
+	examples: [
+		{ command: getCommand('cloud schedule list'), description: 'List schedules' },
+		{
+			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' },
+	],
+});
+
+export default command;

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

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createScheduleAdapter } from './util';
+import { getCommand } from '../../../command-prefix';
+
+const ScheduleListResponseSchema = z.object({
+	schedules: z.array(
+		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(),
+		})
+	),
+	total: z.number(),
+});
+
+export const listSubcommand = createCommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List schedules',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true },
+	idempotent: true,
+	examples: [
+		{ command: getCommand('cloud schedule list'), description: 'List schedules' },
+		{ command: getCommand('cloud schedule list --limit 20'), description: 'List 20 schedules' },
+	],
+	schema: {
+		options: z.object({
+			limit: z.coerce.number().min(0).optional().describe('Maximum number of schedules'),
+			offset: z.coerce.number().min(0).optional().describe('Pagination offset'),
+		}),
+		response: ScheduleListResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { opts, options } = ctx;
+		const schedule = await createScheduleAdapter(ctx);
+		const result = await schedule.list({ limit: opts.limit, offset: opts.offset });
+
+		if (!options.json) {
+			if (result.schedules.length === 0) {
+				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(),
+					})),
+					['Name', 'ID', 'Expression', 'Next Due', 'Created']
+				);
+			}
+		}
+
+		return result;
+	},
+});
+
+export default listSubcommand;

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;