@agentuity/cli 1.0.23 → 1.0.25

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

@@ -32,11 +32,7 @@ export const sendSubcommand = createCommand({
 			tui.fatal('At least one of --text or --html is required');
 		}
 
-		const fileValues = Array.isArray(opts.file)
-			? opts.file
-			: opts.file
-				? [opts.file]
-				: [];
+		const fileValues = Array.isArray(opts.file) ? opts.file : opts.file ? [opts.file] : [];
 
 		const attachments: EmailAttachment[] = [];
 		for (const filePath of fileValues) {
@@ -53,7 +49,7 @@ export const sendSubcommand = createCommand({
 			});
 		}
 
-		const email = createEmailAdapter(ctx);
+		const email = await createEmailAdapter(ctx);
 		const outbound = await email.send({
 			to: [args.to],
 			from: opts.from,
@@ -69,17 +65,15 @@ export const sendSubcommand = createCommand({
 				[
 					{
 						ID: outbound.id,
-						From: outbound.from,
-						To: outbound.to,
-						Subject: outbound.subject ?? '-',
-						Text: truncate(outbound.text),
-						Status: outbound.status ?? '-',
-						Sent: outbound.sent_at
-							? new Date(outbound.sent_at).toLocaleString()
-							: '-',
+						From: outbound.from || opts.from,
+						To: outbound.to || args.to,
+						Subject: outbound.subject ?? opts.subject,
+						Text: truncate(outbound.text ?? opts.text),
+						Status: outbound.status ?? 'pending',
+						Attachments: attachments.length > 0 ? attachments.length.toString() : '-',
 					},
 				],
-				['ID', 'From', 'To', 'Subject', 'Text', 'Status', 'Sent'],
+				['ID', 'From', 'To', 'Subject', 'Text', 'Status', 'Attachments'],
 				{ layout: 'vertical', padStart: '  ' }
 			);
 		}

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

@@ -0,0 +1,73 @@
+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.email;
+	if (!svc) {
+		tui.info('No email data found.');
+		return;
+	}
+	tui.header('Email Statistics');
+	tui.newline();
+	console.log(`  ${tui.muted('Addresses:')}       ${formatNumber(svc.addressCount)}`);
+	console.log(`  ${tui.muted('Inbound:')}         ${formatNumber(svc.inboundCount)}`);
+	console.log(
+		`  ${tui.muted('Outbound:')}        ${formatNumber(svc.outboundCount)} (${svc.outboundSuccess} ok, ${svc.outboundFailed} failed)`
+	);
+}
+
+export const statsSubcommand = createCommand({
+	name: 'stats',
+	description: 'View email statistics',
+	tags: ['read-only', 'requires-auth'],
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('cloud email stats'),
+			description: 'View email 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: 'email',
+			start: opts.start,
+			end: opts.end,
+			orgIdHeader: orgId,
+		});
+
+		if (!options.json) {
+			displayStats(data);
+		}
+
+		return data;
+	},
+});
+
+export default statsSubcommand;

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

@@ -1,8 +1,9 @@
 import { z } from 'zod';
 import { EmailStorageService, 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 type {
@@ -14,47 +15,24 @@ export type {
 	EmailSendParams,
 } from '@agentuity/core';
 
-interface EmailContext {
+export interface EmailContext {
 	logger: Logger;
 	auth: AuthData;
-	region?: string;
-	project?: ProjectConfig;
 	config: Config | null;
 	options: GlobalOptions;
 }
 
-export function resolveEmailOrgId(ctx: EmailContext, explicitOrgId?: string): string {
+export function resolveEmailOrgId(ctx: EmailContext): string {
 	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.');
 	}
 
 	return orgId;
 }
 
-export function resolveEmailRegion(ctx: EmailContext): string {
-	if (ctx.region) {
-		return ctx.region;
-	}
-	if (process.env.AGENTUITY_REGION) {
-		return process.env.AGENTUITY_REGION;
-	}
-	if (ctx.config?.name === 'local') {
-		return 'local';
-	}
-	if (ctx.config?.preferences?.region) {
-		return ctx.config.preferences.region;
-	}
-	return 'usc';
-}
-
 export const EmailAddressSchema = z.object({
 	id: z.string(),
 	email: z.string(),
@@ -72,8 +50,8 @@ export function truncate(value: string | undefined, length = 200): string {
 	return value.length > length ? `${value.slice(0, length - 3)}...` : value;
 }
 
-export function createEmailAdapter(ctx: EmailContext, explicitOrgId?: string) {
-	const orgId = resolveEmailOrgId(ctx, explicitOrgId);
+export async function createEmailAdapter(ctx: EmailContext, region?: string) {
+	const orgId = resolveEmailOrgId(ctx);
 	const adapter = createServerFetchAdapter(
 		{
 			headers: {
@@ -84,6 +62,8 @@ export function createEmailAdapter(ctx: EmailContext, explicitOrgId?: string) {
 		ctx.logger
 	);
 
-	const baseUrl = getCatalystUrl(resolveEmailRegion(ctx));
+	const resolvedRegion =
+		region ?? (await getDefaultRegion(ctx.config?.name ?? defaultProfileName, ctx.config));
+	const baseUrl = getCatalystUrl(resolvedRegion);
 	return new EmailStorageService(baseUrl, adapter);
 }

package/src/cmd/cloud/index.ts

@@ -20,6 +20,7 @@ import { emailCommand } from './email';
 import taskCommand from './task';
 import sandboxCommand from './sandbox';
 import scheduleCommand from './schedule';
+import servicesCommand from './services';
 import { regionSubcommand } from './region';
 import { machineCommand } from './machine';
 import { evalCommand } from './eval';
@@ -54,6 +55,7 @@ export const command = createCommand({
 		dbCommand,
 		redisCommand,
 		storageCommand,
+		servicesCommand,
 		sessionCommand,
 		threadCommand,
 		sshSubcommand,

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

@@ -42,12 +42,12 @@ function displayMessage(message: Message): void {
 	tui.table([details], undefined, { layout: 'vertical' });
 
 	tui.newline();
-	tui.info('Payload');
+	tui.header('Payload');
 	tui.json(message.payload);
 
 	if (message.metadata && Object.keys(message.metadata).length > 0) {
 		tui.newline();
-		tui.info('Metadata');
+		tui.header('Metadata');
 		tui.json(message.metadata);
 	}
 }
@@ -119,7 +119,7 @@ export const getSubcommand = createCommand({
 				queue.next_offset !== undefined
 			) {
 				tui.newline();
-				tui.info('Stats');
+				tui.header('Stats');
 				tui.table(
 					[
 						{
@@ -135,7 +135,7 @@ export const getSubcommand = createCommand({
 
 			if (queue.default_visibility_timeout_seconds !== undefined) {
 				tui.newline();
-				tui.info('Settings');
+				tui.header('Settings');
 				const settings: Record<string, unknown> = {};
 				if (queue.default_ttl_seconds != null) {
 					settings['Default TTL'] = `${queue.default_ttl_seconds}s`;

package/src/cmd/cloud/queue/receive.ts

@@ -55,15 +55,23 @@ export const receiveSubcommand = createCommand({
 				tui.info('No messages available');
 			} else {
 				tui.success(`Received message: ${message.id}`);
-				tui.info(`  Offset: ${message.offset}`);
-				tui.info(`  State: ${message.state}`);
-				tui.info(`  Delivery Attempts: ${message.delivery_attempts}`);
-				tui.info('');
-				tui.info('Payload:');
+				tui.table(
+					[
+						{
+							Offset: message.offset,
+							State: message.state,
+							'Delivery Attempts': message.delivery_attempts,
+						},
+					],
+					undefined,
+					{ layout: 'vertical' }
+				);
+				tui.newline();
+				tui.header('Payload');
 				tui.json(message.payload);
 				if (message.metadata) {
-					tui.info('');
-					tui.info('Metadata:');
+					tui.newline();
+					tui.header('Metadata');
 					tui.json(message.metadata);
 				}
 			}

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

@@ -45,7 +45,7 @@ function formatDuration(start: string, end: string): string {
 function displayOrgAnalytics(analytics: OrgAnalytics): void {
 	const { summary, queues, period } = analytics;
 
-	tui.info(`Organization Analytics (${formatDuration(period.start, period.end)})`);
+	tui.header(`Organization Analytics (${formatDuration(period.start, period.end)})`);
 	tui.newline();
 	console.log(tui.colorPrimary('Summary:'));
 	console.log(`  ${tui.muted('Total Queues:')}     ${summary.total_queues}`);
@@ -84,7 +84,7 @@ function displayQueueAnalytics(analytics: QueueAnalytics): void {
 	const { queue_name, queue_type, period, current, period_stats, latency, consumer_latency } =
 		analytics;
 
-	tui.info(`Queue: ${queue_name} (${queue_type})`);
+	tui.header(`Queue: ${queue_name} (${queue_type})`);
 	console.log(tui.colorWarning(`Period: ${formatDuration(period.start, period.end)}`));
 	tui.newline();
 
@@ -146,7 +146,7 @@ function displayQueueAnalytics(analytics: QueueAnalytics): void {
 
 	if (analytics.destinations && analytics.destinations.length > 0) {
 		tui.newline();
-		tui.info('Destinations:');
+		tui.header('Destinations');
 		const destData = analytics.destinations.map((d) => {
 			const total = d.success_count + d.failure_count;
 			const errorRate = total > 0 ? (d.failure_count / total) * 100 : 0;

package/src/cmd/cloud/sandbox/checkpoint/create.ts

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+import { createCommand } from '../../../../types';
+import * as tui from '../../../../tui';
+import { createSandboxClient } from '../util';
+import { getCommand } from '../../../../command-prefix';
+import { sandboxResolve, diskCheckpointCreate } from '@agentuity/server';
+
+const CheckpointCreateResponseSchema = z.object({
+	success: z.boolean().describe('Whether the operation succeeded'),
+	sandboxId: z.string().describe('Sandbox ID'),
+	checkpointId: z.string().describe('Created checkpoint ID'),
+	name: z.string().describe('Checkpoint name'),
+	createdAt: z.string().describe('Checkpoint creation timestamp'),
+	parent: z.string().describe('Parent checkpoint name'),
+	durationMs: z.number().describe('Operation duration in milliseconds'),
+});
+
+export const createSubcommand = createCommand({
+	name: 'create',
+	description: 'Create a disk checkpoint of the sandbox filesystem',
+	tags: ['slow', 'requires-auth'],
+	requires: { auth: true, apiClient: true },
+	idempotent: false,
+	examples: [
+		{
+			command: getCommand('cloud sandbox checkpoint create sbx_abc123 my-checkpoint'),
+			description: 'Create a disk checkpoint',
+		},
+	],
+	schema: {
+		args: z.object({
+			sandboxId: z.string().describe('Sandbox ID'),
+			name: z.string().describe('Checkpoint name'),
+		}),
+		options: z.object({}),
+		response: CheckpointCreateResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options, auth, logger, apiClient } = ctx;
+
+		const started = Date.now();
+
+		// Resolve sandbox to get region and orgId using CLI API
+		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
+
+		const client = createSandboxClient(logger, auth, sandboxInfo.region);
+
+		const checkpoint = await diskCheckpointCreate(client, {
+			sandboxId: args.sandboxId,
+			name: args.name,
+			orgId: sandboxInfo.orgId,
+		});
+		const durationMs = Date.now() - started;
+
+		if (!options.json) {
+			tui.success(`created disk checkpoint ${tui.bold(checkpoint.id)} in ${durationMs}ms`);
+
+			tui.table(
+				[
+					{
+						ID: checkpoint.id,
+						Name: checkpoint.name,
+						'Created At': checkpoint.createdAt,
+						Parent: checkpoint.parent || '-',
+					},
+				],
+				['ID', 'Name', 'Created At', 'Parent'],
+				{ layout: 'vertical', padStart: '  ' }
+			);
+		}
+
+		return {
+			success: true,
+			sandboxId: args.sandboxId,
+			checkpointId: checkpoint.id,
+			name: checkpoint.name,
+			createdAt: checkpoint.createdAt,
+			parent: checkpoint.parent,
+			durationMs,
+		};
+	},
+});
+
+export default createSubcommand;

package/src/cmd/cloud/sandbox/checkpoint/delete.ts

@@ -0,0 +1,93 @@
+import { z } from 'zod';
+import { createCommand } from '../../../../types';
+import * as tui from '../../../../tui';
+import { createSandboxClient } from '../util';
+import { getCommand } from '../../../../command-prefix';
+import { sandboxResolve, diskCheckpointDelete } from '@agentuity/server';
+
+const CheckpointDeleteResponseSchema = z.object({
+	success: z.boolean().describe('Whether the operation succeeded'),
+	sandboxId: z.string().describe('Sandbox ID'),
+	checkpointId: z.string().describe('Deleted checkpoint ID'),
+	durationMs: z.number().describe('Operation duration in milliseconds'),
+	message: z.string().optional().describe('Status message'),
+});
+
+export const deleteSubcommand = createCommand({
+	name: 'delete',
+	aliases: ['del', 'rm', 'remove'],
+	description: 'Delete a disk checkpoint',
+	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth'],
+	requires: { auth: true, apiClient: true },
+	idempotent: true,
+	examples: [
+		{
+			command: getCommand('cloud sandbox checkpoint delete sbx_abc123 ckpt_def456'),
+			description: 'Delete a disk checkpoint',
+		},
+		{
+			command: getCommand('cloud sandbox checkpoint delete sbx_abc123 ckpt_def456 --confirm'),
+			description: 'Delete without confirmation prompt',
+		},
+	],
+	schema: {
+		args: z.object({
+			sandboxId: z.string().describe('Sandbox ID'),
+			checkpointId: z.string().describe('Checkpoint ID or name'),
+		}),
+		options: z.object({
+			confirm: z.boolean().optional().default(false).describe('Skip confirmation prompt'),
+		}),
+		response: CheckpointDeleteResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options, opts, auth, logger, apiClient } = ctx;
+
+		if (!opts.confirm) {
+			const confirmed = await tui.confirm(
+				`Delete disk checkpoint "${args.checkpointId}" from sandbox "${args.sandboxId}"?`,
+				false
+			);
+			if (!confirmed) {
+				logger.info('Cancelled');
+				return {
+					success: false,
+					sandboxId: args.sandboxId,
+					checkpointId: args.checkpointId,
+					durationMs: 0,
+					message: 'Cancelled',
+				};
+			}
+		}
+
+		const started = Date.now();
+
+		// Resolve sandbox to get region and orgId using CLI API
+		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
+
+		const client = createSandboxClient(logger, auth, sandboxInfo.region);
+
+		await diskCheckpointDelete(client, {
+			sandboxId: args.sandboxId,
+			checkpointId: args.checkpointId,
+			orgId: sandboxInfo.orgId,
+		});
+		const durationMs = Date.now() - started;
+
+		if (!options.json) {
+			tui.success(
+				`deleted disk checkpoint ${tui.bold(args.checkpointId)} from sandbox ${tui.bold(args.sandboxId)} in ${durationMs}ms`
+			);
+		}
+
+		return {
+			success: true,
+			sandboxId: args.sandboxId,
+			checkpointId: args.checkpointId,
+			durationMs,
+		};
+	},
+});
+
+export default deleteSubcommand;

package/src/cmd/cloud/sandbox/checkpoint/index.ts

@@ -0,0 +1,33 @@
+import { createCommand } from '../../../../types';
+import { createSubcommand } from './create';
+import { listSubcommand } from './list';
+import { restoreSubcommand } from './restore';
+import { deleteSubcommand } from './delete';
+import { getCommand } from '../../../../command-prefix';
+
+export const checkpointCommand = createCommand({
+	name: 'checkpoint',
+	aliases: ['ckpt'],
+	description: 'Manage disk checkpoints for sandbox filesystem',
+	tags: ['slow', 'requires-auth'],
+	requires: { auth: true, apiClient: true },
+	examples: [
+		{
+			command: getCommand('cloud sandbox checkpoint create sbx_abc123 my-checkpoint'),
+			description: 'Create a disk checkpoint',
+		},
+		{
+			command: getCommand('cloud sandbox checkpoint list sbx_abc123'),
+			description: 'List disk checkpoints',
+		},
+		{
+			command: getCommand('cloud sandbox checkpoint restore sbx_abc123 ckpt_def456'),
+			description: 'Restore a disk checkpoint',
+		},
+		{
+			command: getCommand('cloud sandbox checkpoint delete sbx_abc123 ckpt_def456'),
+			description: 'Delete a disk checkpoint',
+		},
+	],
+	subcommands: [createSubcommand, listSubcommand, restoreSubcommand, deleteSubcommand],
+});

package/src/cmd/cloud/sandbox/checkpoint/list.ts

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+import { createCommand } from '../../../../types';
+import * as tui from '../../../../tui';
+import { createSandboxClient } from '../util';
+import { getCommand } from '../../../../command-prefix';
+import { sandboxResolve, diskCheckpointList } from '@agentuity/server';
+
+const CheckpointInfoSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	createdAt: z.string(),
+	parent: z.string(),
+});
+
+const CheckpointListResponseSchema = z.object({
+	checkpoints: z.array(CheckpointInfoSchema).describe('List of disk checkpoints'),
+	total: z.number().describe('Total number of checkpoints'),
+});
+
+export const listSubcommand = createCommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List disk checkpoints for a sandbox',
+	tags: ['slow', 'requires-auth'],
+	requires: { auth: true, apiClient: true },
+	examples: [
+		{
+			command: getCommand('cloud sandbox checkpoint list sbx_abc123'),
+			description: 'List disk checkpoints for a sandbox',
+		},
+	],
+	schema: {
+		args: z.object({
+			sandboxId: z.string().describe('Sandbox ID'),
+		}),
+		options: z.object({}),
+		response: CheckpointListResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options, auth, logger, apiClient } = ctx;
+
+		// Resolve sandbox to get region and orgId using CLI API
+		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
+
+		const client = createSandboxClient(logger, auth, sandboxInfo.region);
+
+		const checkpoints = await diskCheckpointList(client, {
+			sandboxId: args.sandboxId,
+			orgId: sandboxInfo.orgId,
+		});
+
+		if (!options.json) {
+			if (checkpoints.length === 0) {
+				tui.info('No disk checkpoints found');
+			} else {
+				const tableData = checkpoints.map((ckpt) => ({
+					ID: ckpt.id,
+					Name: ckpt.name,
+					'Created At': ckpt.createdAt,
+					Parent: ckpt.parent || '-',
+				}));
+				tui.table(tableData, [
+					{ name: 'ID', alignment: 'left' },
+					{ name: 'Name', alignment: 'left' },
+					{ name: 'Created At', alignment: 'left' },
+					{ name: 'Parent', alignment: 'left' },
+				]);
+
+				tui.info(
+					`Total: ${checkpoints.length} ${tui.plural(checkpoints.length, 'checkpoint', 'checkpoints')}`
+				);
+			}
+		}
+
+		return {
+			checkpoints,
+			total: checkpoints.length,
+		};
+	},
+});
+
+export default listSubcommand;

package/src/cmd/cloud/sandbox/checkpoint/restore.ts

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+import { createCommand } from '../../../../types';
+import * as tui from '../../../../tui';
+import { createSandboxClient } from '../util';
+import { getCommand } from '../../../../command-prefix';
+import { sandboxResolve, diskCheckpointRestore } from '@agentuity/server';
+
+const CheckpointRestoreResponseSchema = z.object({
+	success: z.boolean().describe('Whether the operation succeeded'),
+	sandboxId: z.string().describe('Sandbox ID'),
+	checkpointId: z.string().describe('Restored checkpoint ID'),
+	durationMs: z.number().describe('Operation duration in milliseconds'),
+});
+
+export const restoreSubcommand = createCommand({
+	name: 'restore',
+	description: 'Restore a sandbox to a disk checkpoint',
+	tags: ['slow', 'requires-auth'],
+	requires: { auth: true, apiClient: true },
+	idempotent: false,
+	examples: [
+		{
+			command: getCommand('cloud sandbox checkpoint restore sbx_abc123 ckpt_def456'),
+			description: 'Restore a sandbox to a checkpoint by ID',
+		},
+		{
+			command: getCommand('cloud sandbox checkpoint restore sbx_abc123 my-checkpoint'),
+			description: 'Restore a sandbox to a checkpoint by name',
+		},
+	],
+	schema: {
+		args: z.object({
+			sandboxId: z.string().describe('Sandbox ID'),
+			checkpointId: z.string().describe('Checkpoint ID or name'),
+		}),
+		options: z.object({}),
+		response: CheckpointRestoreResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options, auth, logger, apiClient } = ctx;
+
+		const started = Date.now();
+
+		// Resolve sandbox to get region and orgId using CLI API
+		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
+
+		const client = createSandboxClient(logger, auth, sandboxInfo.region);
+
+		await diskCheckpointRestore(client, {
+			sandboxId: args.sandboxId,
+			checkpointId: args.checkpointId,
+			orgId: sandboxInfo.orgId,
+		});
+		const durationMs = Date.now() - started;
+
+		if (!options.json) {
+			tui.success(
+				`restored sandbox ${tui.bold(args.sandboxId)} to checkpoint ${tui.bold(args.checkpointId)} in ${durationMs}ms`
+			);
+		}
+
+		return {
+			success: true,
+			sandboxId: args.sandboxId,
+			checkpointId: args.checkpointId,
+			durationMs,
+		};
+	},
+});
+
+export default restoreSubcommand;