@agentuity/cli 1.0.22 → 1.0.24

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;

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

@@ -147,14 +147,17 @@ export const getSubcommand = createCommand({
 			if (resourceParts.length > 0) {
 				tableData['Resources'] = resourceParts.join(', ');
 			}
-			if (result.metadata && Object.keys(result.metadata).length > 0) {
-				tableData['Metadata'] = JSON.stringify(result.metadata);
-			}
 			if (result.url) {
 				tableData['URL'] = tui.link(result.url);
 			}
 
 			tui.table([tableData], Object.keys(tableData), { layout: 'vertical', padStart: '  ' });
+
+			if (result.metadata && Object.keys(result.metadata).length > 0) {
+				tui.newline();
+				tui.header('Metadata');
+				tui.json(result.metadata);
+			}
 		}
 
 		return {

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

@@ -18,6 +18,8 @@ import { uploadSubcommand } from './upload';
 import { envSubcommand } from './env';
 import { pauseSubcommand } from './pause';
 import { resumeSubcommand } from './resume';
+import { checkpointCommand } from './checkpoint';
+import { statsSubcommand } from './stats';
 import { getCommand } from '../../../command-prefix';
 
 export const command = createCommand({
@@ -59,6 +61,8 @@ export const command = createCommand({
 		envSubcommand,
 		pauseSubcommand,
 		resumeSubcommand,
+		checkpointCommand,
+		statsSubcommand,
 	],
 	requires: { auth: true, org: true },
 });